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", "uububu", "ububuu"];
96 export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
97 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
98 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
99 await finishInitializeWasm(wasmInstance);
103 export async function initializeWasmFetch(uri: string) {
104 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
105 const stream = fetch(uri);
106 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
107 await finishInitializeWasm(wasmInstance);
112 export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
113 const arr = new Uint8Array(inputArray.length);
114 for (var i = 0; i < inputArray.length; i++) {
115 arr[i] = inputArray[i]!.getVal();
121 export function WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): Uint8Array {
122 const arr = new Uint8Array(inputArray.length);
123 for (var i = 0; i < inputArray.length; i++) {
124 arr[i] = inputArray[i]!.getVal();
132 export function encodeUint128 (inputVal: bigint): number {
133 if (inputVal >= 0x10000000000000000000000000000000n) throw "U128s cannot exceed 128 bits";
134 const cArrayPointer = wasm.TS_malloc(16 + 8);
135 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
136 arrayLengthView[0] = BigInt(16);
137 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, 16);
138 for (var i = 0; i < 16; i++) arrayMemoryView[i] = Number((inputVal >> BigInt(i)*8n) & 0xffn);
139 return cArrayPointer;
142 export function encodeUint8Array (inputArray: Uint8Array|null): number {
143 if (inputArray == null) return 0;
144 const cArrayPointer = wasm.TS_malloc(inputArray.length + 8);
145 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
146 arrayLengthView[0] = BigInt(inputArray.length);
147 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
148 arrayMemoryView.set(inputArray);
149 return cArrayPointer;
152 export function 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 * Errors that may occur when converting a [`RawBolt11Invoice`] to a [`Bolt11Invoice`]. They relate to
304 * the requirements sections in BOLT #11
306 export enum Bolt11SemanticError {
308 * The invoice is missing the mandatory payment hash
310 LDKBolt11SemanticError_NoPaymentHash,
312 * The invoice has multiple payment hashes which isn't allowed
314 LDKBolt11SemanticError_MultiplePaymentHashes,
316 * No description or description hash are part of the invoice
318 LDKBolt11SemanticError_NoDescription,
320 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
322 LDKBolt11SemanticError_MultipleDescriptions,
324 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
327 LDKBolt11SemanticError_NoPaymentSecret,
329 * The invoice contains multiple payment secrets
331 LDKBolt11SemanticError_MultiplePaymentSecrets,
333 * The invoice's features are invalid
335 LDKBolt11SemanticError_InvalidFeatures,
337 * The recovery id doesn't fit the signature/pub key
339 LDKBolt11SemanticError_InvalidRecoveryId,
341 * The invoice's signature is invalid
343 LDKBolt11SemanticError_InvalidSignature,
345 * The invoice's amount was not a whole number of millisatoshis
347 LDKBolt11SemanticError_ImpreciseAmount,
352 * Error when interpreting a TLV stream as a specific type.
354 export enum Bolt12SemanticError {
356 * The current [`std::time::SystemTime`] is past the offer or invoice's expiration.
358 LDKBolt12SemanticError_AlreadyExpired,
360 * The provided chain hash does not correspond to a supported chain.
362 LDKBolt12SemanticError_UnsupportedChain,
364 * A chain was provided but was not expected.
366 LDKBolt12SemanticError_UnexpectedChain,
368 * An amount was expected but was missing.
370 LDKBolt12SemanticError_MissingAmount,
372 * The amount exceeded the total bitcoin supply.
374 LDKBolt12SemanticError_InvalidAmount,
376 * An amount was provided but was not sufficient in value.
378 LDKBolt12SemanticError_InsufficientAmount,
380 * An amount was provided but was not expected.
382 LDKBolt12SemanticError_UnexpectedAmount,
384 * A currency was provided that is not supported.
386 LDKBolt12SemanticError_UnsupportedCurrency,
388 * A feature was required but is unknown.
390 LDKBolt12SemanticError_UnknownRequiredFeatures,
392 * Features were provided but were not expected.
394 LDKBolt12SemanticError_UnexpectedFeatures,
396 * A required description was not provided.
398 LDKBolt12SemanticError_MissingDescription,
400 * A signing pubkey was not provided.
402 LDKBolt12SemanticError_MissingSigningPubkey,
404 * A signing pubkey was provided but a different one was expected.
406 LDKBolt12SemanticError_InvalidSigningPubkey,
408 * A signing pubkey was provided but was not expected.
410 LDKBolt12SemanticError_UnexpectedSigningPubkey,
412 * A quantity was expected but was missing.
414 LDKBolt12SemanticError_MissingQuantity,
416 * An unsupported quantity was provided.
418 LDKBolt12SemanticError_InvalidQuantity,
420 * A quantity or quantity bounds was provided but was not expected.
422 LDKBolt12SemanticError_UnexpectedQuantity,
424 * Metadata could not be used to verify the offers message.
426 LDKBolt12SemanticError_InvalidMetadata,
428 * Metadata was provided but was not expected.
430 LDKBolt12SemanticError_UnexpectedMetadata,
432 * Payer metadata was expected but was missing.
434 LDKBolt12SemanticError_MissingPayerMetadata,
436 * A payer id was expected but was missing.
438 LDKBolt12SemanticError_MissingPayerId,
440 * The payment id for a refund or request is already in use.
442 LDKBolt12SemanticError_DuplicatePaymentId,
444 * Blinded paths were expected but were missing.
446 LDKBolt12SemanticError_MissingPaths,
448 * The blinded payinfo given does not match the number of blinded path hops.
450 LDKBolt12SemanticError_InvalidPayInfo,
452 * An invoice creation time was expected but was missing.
454 LDKBolt12SemanticError_MissingCreationTime,
456 * An invoice payment hash was expected but was missing.
458 LDKBolt12SemanticError_MissingPaymentHash,
460 * A signature was expected but was missing.
462 LDKBolt12SemanticError_MissingSignature,
467 * An enum which can either contain a or not
469 export enum COption_NoneZ {
471 * When we're in this state, this COption_NoneZ contains a
473 LDKCOption_NoneZ_Some,
475 * When we're in this state, this COption_NoneZ contains nothing
477 LDKCOption_NoneZ_None,
482 * An enum representing the status of a channel monitor update persistence.
484 * These are generally used as the return value for an implementation of [`Persist`] which is used
485 * as the storage layer for a [`ChainMonitor`]. See the docs on [`Persist`] for a high-level
486 * explanation of how to handle different cases.
488 * While `UnrecoverableError` is provided as a failure variant, it is not truly \"handled\" on the
489 * calling side, and generally results in an immediate panic. For those who prefer to avoid
490 * panics, `InProgress` can be used and you can retry the update operation in the background or
493 * Note that channels should generally *not* be force-closed after a persistence failure.
494 * Force-closing with the latest [`ChannelMonitorUpdate`] applied may result in a transaction
495 * being broadcast which can only be spent by the latest [`ChannelMonitor`]! Thus, if the
496 * latest [`ChannelMonitor`] is not durably persisted anywhere and exists only in memory, naively
497 * calling [`ChannelManager::force_close_broadcasting_latest_txn`] *may result in loss of funds*!
499 * [`Persist`]: chainmonitor::Persist
500 * [`ChainMonitor`]: chainmonitor::ChainMonitor
501 * [`ChannelManager::force_close_broadcasting_latest_txn`]: crate::ln::channelmanager::ChannelManager::force_close_broadcasting_latest_txn
503 export enum ChannelMonitorUpdateStatus {
505 * The update has been durably persisted and all copies of the relevant [`ChannelMonitor`]
508 This includes performing any `fsync()` calls required to ensure the update is guaranteed to
509 be available on restart even if the application crashes.
511 LDKChannelMonitorUpdateStatus_Completed,
513 * Indicates that the update will happen asynchronously in the background or that a transient
514 failure occurred which is being retried in the background and will eventually complete.
516 This will \"freeze\" a channel, preventing us from revoking old states or submitting a new
517 commitment transaction to the counterparty. Once the update(s) which are `InProgress` have
518 been completed, a [`MonitorEvent::Completed`] can be used to restore the channel to an
521 Even when a channel has been \"frozen\", updates to the [`ChannelMonitor`] can continue to
522 occur (e.g. if an inbound HTLC which we forwarded was claimed upstream, resulting in us
523 attempting to claim it on this channel) and those updates must still be persisted.
525 No updates to the channel will be made which could invalidate other [`ChannelMonitor`]s
526 until a [`MonitorEvent::Completed`] is provided, even if you return no error on a later
527 monitor update for the same channel.
529 For deployments where a copy of [`ChannelMonitor`]s and other local state are backed up in
530 a remote location (with local copies persisted immediately), it is anticipated that all
531 updates will return [`InProgress`] until the remote copies could be updated.
533 Note that while fully asynchronous persistence of [`ChannelMonitor`] data is generally
534 reliable, this feature is considered beta, and a handful of edge-cases remain. Until the
535 remaining cases are fixed, in rare cases, *using this feature may lead to funds loss*.
537 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
539 LDKChannelMonitorUpdateStatus_InProgress,
541 * Indicates that an update has failed and will not complete at any point in the future.
543 Currently returning this variant will cause LDK to immediately panic to encourage immediate
544 shutdown. In the future this may be updated to disconnect peers and refuse to continue
545 normal operation without a panic.
547 Applications which wish to perform an orderly shutdown after failure should consider
548 returning [`InProgress`] instead and simply shut down without ever marking the update
551 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
553 LDKChannelMonitorUpdateStatus_UnrecoverableError,
558 * Further information on the details of the channel shutdown.
559 * Upon channels being forced closed (i.e. commitment transaction confirmation detected
560 * by `ChainMonitor`), ChannelShutdownState will be set to `ShutdownComplete` or
561 * the channel will be removed shortly.
562 * Also note, that in normal operation, peers could disconnect at any of these states
563 * and require peer re-connection before making progress onto other states
565 export enum ChannelShutdownState {
567 * Channel has not sent or received a shutdown message.
569 LDKChannelShutdownState_NotShuttingDown,
571 * Local node has sent a shutdown message for this channel.
573 LDKChannelShutdownState_ShutdownInitiated,
575 * Shutdown message exchanges have concluded and the channels are in the midst of
576 resolving all existing open HTLCs before closing can continue.
578 LDKChannelShutdownState_ResolvingHTLCs,
580 * All HTLCs have been resolved, nodes are currently negotiating channel close onchain fee rates.
582 LDKChannelShutdownState_NegotiatingClosingFee,
584 * We've successfully negotiated a closing_signed dance. At this point `ChannelManager` is about
587 LDKChannelShutdownState_ShutdownComplete,
592 * An enum that represents the priority at which we want a transaction to confirm used for feerate
595 export enum ConfirmationTarget {
597 * We have some funds available on chain which we need to spend prior to some expiry time at
598 which point our counterparty may be able to steal them. Generally we have in the high tens
599 to low hundreds of blocks to get our transaction on-chain, but we shouldn't risk too low a
600 fee - this should be a relatively high priority feerate.
602 LDKConfirmationTarget_OnChainSweep,
604 * The highest feerate we will allow our channel counterparty to have in a non-anchor channel.
606 This is the feerate on the transaction which we (or our counterparty) will broadcast in
607 order to close the channel unilaterally. Because our counterparty must ensure they can
608 always broadcast the latest state, this value being too low will cause immediate
611 Allowing this value to be too high can allow our counterparty to burn our HTLC outputs to
612 dust, which can result in HTLCs failing or force-closures (when the dust HTLCs exceed
613 [`ChannelConfig::max_dust_htlc_exposure`]).
615 Because most nodes use a feerate estimate which is based on a relatively high priority
616 transaction entering the current mempool, setting this to a small multiple of your current
617 high priority feerate estimate should suffice.
619 [`ChannelConfig::max_dust_htlc_exposure`]: crate::util::config::ChannelConfig::max_dust_htlc_exposure
621 LDKConfirmationTarget_MaxAllowedNonAnchorChannelRemoteFee,
623 * This is the lowest feerate we will allow our channel counterparty to have in an anchor
624 channel in order to close the channel if a channel party goes away.
626 This needs to be sufficient to get into the mempool when the channel needs to
627 be force-closed. Setting too high may result in force-closures if our counterparty attempts
628 to use a lower feerate. Because this is for anchor channels, we can always bump the feerate
629 later; the feerate here only needs to be sufficient to enter the mempool.
631 A good estimate is the expected mempool minimum at the time of force-closure. Obviously this
632 is not an estimate which is very easy to calculate because we do not know the future. Using
633 a simple long-term fee estimate or tracking of the mempool minimum is a good approach to
634 ensure you can always close the channel. A future change to Bitcoin's P2P network
635 (package relay) may obviate the need for this entirely.
637 LDKConfirmationTarget_MinAllowedAnchorChannelRemoteFee,
639 * The lowest feerate we will allow our channel counterparty to have in a non-anchor channel.
641 This is the feerate on the transaction which we (or our counterparty) will broadcast in
642 order to close the channel if a channel party goes away. Setting this value too high will
643 cause immediate force-closures in order to avoid having an unbroadcastable state.
645 This feerate represents the fee we pick now, which must be sufficient to enter a block at an
646 arbitrary time in the future. Obviously this is not an estimate which is very easy to
647 calculate. This can leave channels subject to being unable to close if feerates rise, and in
648 general you should prefer anchor channels to ensure you can increase the feerate when the
649 transactions need broadcasting.
651 Do note some fee estimators round up to the next full sat/vbyte (ie 250 sats per kw),
652 causing occasional issues with feerate disagreements between an initiator that wants a
653 feerate of 1.1 sat/vbyte and a receiver that wants 1.1 rounded up to 2. If your fee
654 estimator rounds subtracting 250 to your desired feerate here can help avoid this issue.
656 [`ChannelConfig::max_dust_htlc_exposure`]: crate::util::config::ChannelConfig::max_dust_htlc_exposure
658 LDKConfirmationTarget_MinAllowedNonAnchorChannelRemoteFee,
660 * This is the feerate on the transaction which we (or our counterparty) will broadcast in
661 order to close the channel if a channel party goes away.
663 This needs to be sufficient to get into the mempool when the channel needs to
664 be force-closed. Setting too low may result in force-closures. Because this is for anchor
665 channels, it can be a low value as we can always bump the feerate later.
667 A good estimate is the expected mempool minimum at the time of force-closure. Obviously this
668 is not an estimate which is very easy to calculate because we do not know the future. Using
669 a simple long-term fee estimate or tracking of the mempool minimum is a good approach to
670 ensure you can always close the channel. A future change to Bitcoin's P2P network
671 (package relay) may obviate the need for this entirely.
673 LDKConfirmationTarget_AnchorChannelFee,
675 * Lightning is built around the ability to broadcast a transaction in the future to close our
676 channel and claim all pending funds. In order to do so, non-anchor channels are built with
677 transactions which we need to be able to broadcast at some point in the future.
679 This feerate represents the fee we pick now, which must be sufficient to enter a block at an
680 arbitrary time in the future. Obviously this is not an estimate which is very easy to
681 calculate, so most lightning nodes use some relatively high-priority feerate using the
682 current mempool. This leaves channels subject to being unable to close if feerates rise, and
683 in general you should prefer anchor channels to ensure you can increase the feerate when the
684 transactions need broadcasting.
686 Since this should represent the feerate of a channel close that does not need fee
687 bumping, this is also used as an upper bound for our attempted feerate when doing cooperative
688 closure of any channel.
690 LDKConfirmationTarget_NonAnchorChannelFee,
692 * When cooperatively closing a channel, this is the minimum feerate we will accept.
693 Recommended at least within a day or so worth of blocks.
695 This will also be used when initiating a cooperative close of a channel. When closing a
696 channel you can override this fee by using
697 [`ChannelManager::close_channel_with_feerate_and_script`].
699 [`ChannelManager::close_channel_with_feerate_and_script`]: crate::ln::channelmanager::ChannelManager::close_channel_with_feerate_and_script
701 LDKConfirmationTarget_ChannelCloseMinimum,
706 * Errors that may occur when constructing a new [`RawBolt11Invoice`] or [`Bolt11Invoice`]
708 export enum CreationError {
710 * The supplied description string was longer than 639 __bytes__ (see [`Description::new`])
712 LDKCreationError_DescriptionTooLong,
714 * The specified route has too many hops and can't be encoded
716 LDKCreationError_RouteTooLong,
718 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
720 LDKCreationError_TimestampOutOfBounds,
722 * The supplied millisatoshi amount was greater than the total bitcoin supply.
724 LDKCreationError_InvalidAmount,
726 * Route hints were required for this invoice and were missing. Applies to
729 [phantom invoices]: crate::utils::create_phantom_invoice
731 LDKCreationError_MissingRouteHints,
733 * The provided `min_final_cltv_expiry_delta` was less than [`MIN_FINAL_CLTV_EXPIRY_DELTA`].
735 [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
737 LDKCreationError_MinFinalCltvExpiryDeltaTooShort,
742 * Enum representing the crypto currencies (or networks) supported by this library
744 export enum Currency {
752 LDKCurrency_BitcoinTestnet,
769 * Describes the type of HTLC claim as determined by analyzing the witness.
771 export enum HTLCClaim {
773 * Claims an offered output on a commitment transaction through the timeout path.
775 LDKHTLCClaim_OfferedTimeout,
777 * Claims an offered output on a commitment transaction through the success path.
779 LDKHTLCClaim_OfferedPreimage,
781 * Claims an accepted output on a commitment transaction through the timeout path.
783 LDKHTLCClaim_AcceptedTimeout,
785 * Claims an accepted output on a commitment transaction through the success path.
787 LDKHTLCClaim_AcceptedPreimage,
789 * Claims an offered/accepted output on a commitment transaction through the revocation path.
791 LDKHTLCClaim_Revocation,
796 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
798 export enum IOError {
800 LDKIOError_PermissionDenied,
801 LDKIOError_ConnectionRefused,
802 LDKIOError_ConnectionReset,
803 LDKIOError_ConnectionAborted,
804 LDKIOError_NotConnected,
805 LDKIOError_AddrInUse,
806 LDKIOError_AddrNotAvailable,
807 LDKIOError_BrokenPipe,
808 LDKIOError_AlreadyExists,
809 LDKIOError_WouldBlock,
810 LDKIOError_InvalidInput,
811 LDKIOError_InvalidData,
813 LDKIOError_WriteZero,
814 LDKIOError_Interrupted,
816 LDKIOError_UnexpectedEof,
821 * An enum representing the available verbosity levels of the logger.
825 * Designates extremely verbose information, including gossip-induced messages
829 * Designates very low priority, often extremely verbose, information
833 * Designates lower priority information
837 * Designates useful information
841 * Designates hazardous situations
845 * Designates very serious errors
852 * An enum representing the possible Bitcoin or test networks which we can run on
854 export enum Network {
856 * The main Bitcoin blockchain.
860 * The testnet3 blockchain.
864 * A local test blockchain.
868 * A blockchain on which blocks are signed instead of mined.
875 * The reason the payment failed. Used in [`Event::PaymentFailed`].
877 export enum PaymentFailureReason {
879 * The intended recipient rejected our payment.
881 LDKPaymentFailureReason_RecipientRejected,
883 * The user chose to abandon this payment by calling [`ChannelManager::abandon_payment`].
885 [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
887 LDKPaymentFailureReason_UserAbandoned,
889 * We exhausted all of our retry attempts while trying to send the payment, or we
890 exhausted the [`Retry::Timeout`] if the user set one. If at any point a retry
891 attempt failed while being forwarded along the path, an [`Event::PaymentPathFailed`] will
892 have come before this.
894 [`Retry::Timeout`]: crate::ln::channelmanager::Retry::Timeout
896 LDKPaymentFailureReason_RetriesExhausted,
898 * The payment expired while retrying, based on the provided
899 [`PaymentParameters::expiry_time`].
901 [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
903 LDKPaymentFailureReason_PaymentExpired,
905 * We failed to find a route while retrying the payment.
907 LDKPaymentFailureReason_RouteNotFound,
909 * This error should generally never happen. This likely means that there is a problem with
912 LDKPaymentFailureReason_UnexpectedError,
917 * Specifies the recipient of an invoice.
919 * This indicates to [`NodeSigner::sign_invoice`] what node secret key should be used to sign
922 export enum Recipient {
924 * The invoice should be signed with the local node secret key.
928 * The invoice should be signed with the phantom node secret key. This secret key must be the
929 same for all nodes participating in the [phantom node payment].
931 [phantom node payment]: PhantomKeysManager
933 LDKRecipient_PhantomNode,
938 * Indicates an immediate error on [`ChannelManager::send_payment`]. Further errors may be
939 * surfaced later via [`Event::PaymentPathFailed`] and [`Event::PaymentFailed`].
941 * [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
942 * [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
943 * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
945 export enum RetryableSendFailure {
947 * The provided [`PaymentParameters::expiry_time`] indicated that the payment has expired. Note
948 that this error is *not* caused by [`Retry::Timeout`].
950 [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
952 LDKRetryableSendFailure_PaymentExpired,
954 * We were unable to find a route to the destination.
956 LDKRetryableSendFailure_RouteNotFound,
958 * Indicates that a payment for the provided [`PaymentId`] is already in-flight and has not
959 yet completed (i.e. generated an [`Event::PaymentSent`] or [`Event::PaymentFailed`]).
961 [`PaymentId`]: crate::ln::channelmanager::PaymentId
962 [`Event::PaymentSent`]: crate::events::Event::PaymentSent
963 [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
965 LDKRetryableSendFailure_DuplicatePayment,
970 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
972 export enum Secp256k1Error {
974 * Signature failed verification
976 LDKSecp256k1Error_IncorrectSignature,
978 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
980 LDKSecp256k1Error_InvalidMessage,
984 LDKSecp256k1Error_InvalidPublicKey,
988 LDKSecp256k1Error_InvalidSignature,
992 LDKSecp256k1Error_InvalidSecretKey,
996 LDKSecp256k1Error_InvalidSharedSecret,
1000 LDKSecp256k1Error_InvalidRecoveryId,
1002 * Invalid tweak for add_assign or mul_assign
1004 LDKSecp256k1Error_InvalidTweak,
1006 * Didn't pass enough memory to context creation with preallocated memory
1008 LDKSecp256k1Error_NotEnoughMemory,
1010 * Bad set of public keys.
1012 LDKSecp256k1Error_InvalidPublicKeySum,
1014 * The only valid parity values are 0 or 1.
1016 LDKSecp256k1Error_InvalidParityValue,
1021 * SI prefixes for the human readable part
1023 export enum SiPrefix {
1044 * [`SocketAddress`] error variants
1046 export enum SocketAddressParseError {
1048 * Socket address (IPv4/IPv6) parsing error
1050 LDKSocketAddressParseError_SocketAddrParse,
1052 * Invalid input format
1054 LDKSocketAddressParseError_InvalidInput,
1058 LDKSocketAddressParseError_InvalidPort,
1060 * Invalid onion v3 address
1062 LDKSocketAddressParseError_InvalidOnionV3,
1067 * An error when accessing the chain via [`UtxoLookup`].
1069 export enum UtxoLookupError {
1071 * The requested chain is unknown.
1073 LDKUtxoLookupError_UnknownChain,
1075 * The requested transaction doesn't exist or hasn't confirmed.
1077 LDKUtxoLookupError_UnknownTx,
1080 // struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing)
1082 export function BigEndianScalar_get_bytes(thing: bigint): number {
1083 if(!isWasmInitialized) {
1084 throw new Error("initializeWasm() must be awaited first!");
1086 const nativeResponseValue = wasm.TS_BigEndianScalar_get_bytes(thing);
1087 return nativeResponseValue;
1089 // static void BigEndianScalar_free (struct LDKBigEndianScalar thing)
1091 export function BigEndianScalar_free(thing: bigint): void {
1092 if(!isWasmInitialized) {
1093 throw new Error("initializeWasm() must be awaited first!");
1095 const nativeResponseValue = wasm.TS_BigEndianScalar_free(thing);
1096 // debug statements here
1099 export class LDKBech32Error {
1100 protected constructor() {}
1103 export function LDKBech32Error_ty_from_ptr(ptr: bigint): number {
1104 if(!isWasmInitialized) {
1105 throw new Error("initializeWasm() must be awaited first!");
1107 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
1108 return nativeResponseValue;
1111 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: bigint): number {
1112 if(!isWasmInitialized) {
1113 throw new Error("initializeWasm() must be awaited first!");
1115 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
1116 return nativeResponseValue;
1119 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: bigint): number {
1120 if(!isWasmInitialized) {
1121 throw new Error("initializeWasm() must be awaited first!");
1123 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
1124 return nativeResponseValue;
1126 // struct LDKWitness TxIn_get_witness (struct LDKTxIn* thing)
1128 export function TxIn_get_witness(thing: bigint): number {
1129 if(!isWasmInitialized) {
1130 throw new Error("initializeWasm() must be awaited first!");
1132 const nativeResponseValue = wasm.TS_TxIn_get_witness(thing);
1133 return nativeResponseValue;
1135 // struct LDKCVec_u8Z TxIn_get_script_sig (struct LDKTxIn* thing)
1137 export function TxIn_get_script_sig(thing: bigint): number {
1138 if(!isWasmInitialized) {
1139 throw new Error("initializeWasm() must be awaited first!");
1141 const nativeResponseValue = wasm.TS_TxIn_get_script_sig(thing);
1142 return nativeResponseValue;
1144 // LDKThirtyTwoBytes TxIn_get_previous_txid (struct LDKTxIn* thing)
1146 export function TxIn_get_previous_txid(thing: bigint): number {
1147 if(!isWasmInitialized) {
1148 throw new Error("initializeWasm() must be awaited first!");
1150 const nativeResponseValue = wasm.TS_TxIn_get_previous_txid(thing);
1151 return nativeResponseValue;
1153 // uint32_t TxIn_get_previous_vout (struct LDKTxIn* thing)
1155 export function TxIn_get_previous_vout(thing: bigint): number {
1156 if(!isWasmInitialized) {
1157 throw new Error("initializeWasm() must be awaited first!");
1159 const nativeResponseValue = wasm.TS_TxIn_get_previous_vout(thing);
1160 return nativeResponseValue;
1162 // uint32_t TxIn_get_sequence (struct LDKTxIn* thing)
1164 export function TxIn_get_sequence(thing: bigint): number {
1165 if(!isWasmInitialized) {
1166 throw new Error("initializeWasm() must be awaited first!");
1168 const nativeResponseValue = wasm.TS_TxIn_get_sequence(thing);
1169 return nativeResponseValue;
1171 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
1173 export function TxOut_get_script_pubkey(thing: bigint): number {
1174 if(!isWasmInitialized) {
1175 throw new Error("initializeWasm() must be awaited first!");
1177 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
1178 return nativeResponseValue;
1180 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
1182 export function TxOut_get_value(thing: bigint): bigint {
1183 if(!isWasmInitialized) {
1184 throw new Error("initializeWasm() must be awaited first!");
1186 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
1187 return nativeResponseValue;
1190 export class LDKCOption_u64Z {
1191 protected constructor() {}
1194 export function LDKCOption_u64Z_ty_from_ptr(ptr: bigint): number {
1195 if(!isWasmInitialized) {
1196 throw new Error("initializeWasm() must be awaited first!");
1198 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1199 return nativeResponseValue;
1202 export function LDKCOption_u64Z_Some_get_some(ptr: bigint): bigint {
1203 if(!isWasmInitialized) {
1204 throw new Error("initializeWasm() must be awaited first!");
1206 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1207 return nativeResponseValue;
1209 // struct LDKRefund CResult_RefundBolt12ParseErrorZ_get_ok(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner);
1211 export function CResult_RefundBolt12ParseErrorZ_get_ok(owner: bigint): bigint {
1212 if(!isWasmInitialized) {
1213 throw new Error("initializeWasm() must be awaited first!");
1215 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_get_ok(owner);
1216 return nativeResponseValue;
1218 // struct LDKBolt12ParseError CResult_RefundBolt12ParseErrorZ_get_err(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner);
1220 export function CResult_RefundBolt12ParseErrorZ_get_err(owner: bigint): bigint {
1221 if(!isWasmInitialized) {
1222 throw new Error("initializeWasm() must be awaited first!");
1224 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_get_err(owner);
1225 return nativeResponseValue;
1228 export class LDKRetry {
1229 protected constructor() {}
1232 export function LDKRetry_ty_from_ptr(ptr: bigint): number {
1233 if(!isWasmInitialized) {
1234 throw new Error("initializeWasm() must be awaited first!");
1236 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
1237 return nativeResponseValue;
1240 export function LDKRetry_Attempts_get_attempts(ptr: bigint): number {
1241 if(!isWasmInitialized) {
1242 throw new Error("initializeWasm() must be awaited first!");
1244 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
1245 return nativeResponseValue;
1248 export class LDKDecodeError {
1249 protected constructor() {}
1252 export function LDKDecodeError_ty_from_ptr(ptr: bigint): number {
1253 if(!isWasmInitialized) {
1254 throw new Error("initializeWasm() must be awaited first!");
1256 const nativeResponseValue = wasm.TS_LDKDecodeError_ty_from_ptr(ptr);
1257 return nativeResponseValue;
1260 export function LDKDecodeError_Io_get_io(ptr: bigint): IOError {
1261 if(!isWasmInitialized) {
1262 throw new Error("initializeWasm() must be awaited first!");
1264 const nativeResponseValue = wasm.TS_LDKDecodeError_Io_get_io(ptr);
1265 return nativeResponseValue;
1267 // struct LDKRetry CResult_RetryDecodeErrorZ_get_ok(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR owner);
1269 export function CResult_RetryDecodeErrorZ_get_ok(owner: bigint): bigint {
1270 if(!isWasmInitialized) {
1271 throw new Error("initializeWasm() must be awaited first!");
1273 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_get_ok(owner);
1274 return nativeResponseValue;
1276 // struct LDKDecodeError CResult_RetryDecodeErrorZ_get_err(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR owner);
1278 export function CResult_RetryDecodeErrorZ_get_err(owner: bigint): bigint {
1279 if(!isWasmInitialized) {
1280 throw new Error("initializeWasm() must be awaited first!");
1282 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_get_err(owner);
1283 return nativeResponseValue;
1286 export class LDKAPIError {
1287 protected constructor() {}
1290 export function LDKAPIError_ty_from_ptr(ptr: bigint): number {
1291 if(!isWasmInitialized) {
1292 throw new Error("initializeWasm() must be awaited first!");
1294 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
1295 return nativeResponseValue;
1298 export function LDKAPIError_APIMisuseError_get_err(ptr: bigint): number {
1299 if(!isWasmInitialized) {
1300 throw new Error("initializeWasm() must be awaited first!");
1302 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
1303 return nativeResponseValue;
1306 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: bigint): number {
1307 if(!isWasmInitialized) {
1308 throw new Error("initializeWasm() must be awaited first!");
1310 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
1311 return nativeResponseValue;
1314 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: bigint): number {
1315 if(!isWasmInitialized) {
1316 throw new Error("initializeWasm() must be awaited first!");
1318 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
1319 return nativeResponseValue;
1322 export function LDKAPIError_InvalidRoute_get_err(ptr: bigint): number {
1323 if(!isWasmInitialized) {
1324 throw new Error("initializeWasm() must be awaited first!");
1326 const nativeResponseValue = wasm.TS_LDKAPIError_InvalidRoute_get_err(ptr);
1327 return nativeResponseValue;
1330 export function LDKAPIError_ChannelUnavailable_get_err(ptr: bigint): number {
1331 if(!isWasmInitialized) {
1332 throw new Error("initializeWasm() must be awaited first!");
1334 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
1335 return nativeResponseValue;
1338 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: bigint): bigint {
1339 if(!isWasmInitialized) {
1340 throw new Error("initializeWasm() must be awaited first!");
1342 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
1343 return nativeResponseValue;
1345 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
1347 export function CResult_NoneAPIErrorZ_get_ok(owner: bigint): void {
1348 if(!isWasmInitialized) {
1349 throw new Error("initializeWasm() must be awaited first!");
1351 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
1352 // debug statements here
1354 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
1356 export function CResult_NoneAPIErrorZ_get_err(owner: bigint): bigint {
1357 if(!isWasmInitialized) {
1358 throw new Error("initializeWasm() must be awaited first!");
1360 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
1361 return nativeResponseValue;
1364 export class LDKCOption_ThirtyTwoBytesZ {
1365 protected constructor() {}
1368 export function LDKCOption_ThirtyTwoBytesZ_ty_from_ptr(ptr: bigint): number {
1369 if(!isWasmInitialized) {
1370 throw new Error("initializeWasm() must be awaited first!");
1372 const nativeResponseValue = wasm.TS_LDKCOption_ThirtyTwoBytesZ_ty_from_ptr(ptr);
1373 return nativeResponseValue;
1376 export function LDKCOption_ThirtyTwoBytesZ_Some_get_some(ptr: bigint): number {
1377 if(!isWasmInitialized) {
1378 throw new Error("initializeWasm() must be awaited first!");
1380 const nativeResponseValue = wasm.TS_LDKCOption_ThirtyTwoBytesZ_Some_get_some(ptr);
1381 return nativeResponseValue;
1384 export class LDKCOption_CVec_u8ZZ {
1385 protected constructor() {}
1388 export function LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr: bigint): number {
1389 if(!isWasmInitialized) {
1390 throw new Error("initializeWasm() must be awaited first!");
1392 const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr);
1393 return nativeResponseValue;
1396 export function LDKCOption_CVec_u8ZZ_Some_get_some(ptr: bigint): number {
1397 if(!isWasmInitialized) {
1398 throw new Error("initializeWasm() must be awaited first!");
1400 const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_Some_get_some(ptr);
1401 return nativeResponseValue;
1403 // struct LDKRecipientOnionFields CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
1405 export function CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner: bigint): bigint {
1406 if(!isWasmInitialized) {
1407 throw new Error("initializeWasm() must be awaited first!");
1409 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner);
1410 return nativeResponseValue;
1412 // struct LDKDecodeError CResult_RecipientOnionFieldsDecodeErrorZ_get_err(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
1414 export function CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner: bigint): bigint {
1415 if(!isWasmInitialized) {
1416 throw new Error("initializeWasm() must be awaited first!");
1418 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner);
1419 return nativeResponseValue;
1421 // uint64_t C2Tuple_u64CVec_u8ZZ_get_a(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR owner);
1423 export function C2Tuple_u64CVec_u8ZZ_get_a(owner: bigint): bigint {
1424 if(!isWasmInitialized) {
1425 throw new Error("initializeWasm() must be awaited first!");
1427 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_get_a(owner);
1428 return nativeResponseValue;
1430 // struct LDKCVec_u8Z C2Tuple_u64CVec_u8ZZ_get_b(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR owner);
1432 export function C2Tuple_u64CVec_u8ZZ_get_b(owner: bigint): number {
1433 if(!isWasmInitialized) {
1434 throw new Error("initializeWasm() must be awaited first!");
1436 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_get_b(owner);
1437 return nativeResponseValue;
1439 // struct LDKRecipientOnionFields CResult_RecipientOnionFieldsNoneZ_get_ok(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR owner);
1441 export function CResult_RecipientOnionFieldsNoneZ_get_ok(owner: bigint): bigint {
1442 if(!isWasmInitialized) {
1443 throw new Error("initializeWasm() must be awaited first!");
1445 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_get_ok(owner);
1446 return nativeResponseValue;
1448 // void CResult_RecipientOnionFieldsNoneZ_get_err(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR owner);
1450 export function CResult_RecipientOnionFieldsNoneZ_get_err(owner: bigint): void {
1451 if(!isWasmInitialized) {
1452 throw new Error("initializeWasm() must be awaited first!");
1454 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_get_err(owner);
1455 // debug statements here
1458 export class LDKCOption_CVec_ThirtyTwoBytesZZ {
1459 protected constructor() {}
1462 export function LDKCOption_CVec_ThirtyTwoBytesZZ_ty_from_ptr(ptr: bigint): number {
1463 if(!isWasmInitialized) {
1464 throw new Error("initializeWasm() must be awaited first!");
1466 const nativeResponseValue = wasm.TS_LDKCOption_CVec_ThirtyTwoBytesZZ_ty_from_ptr(ptr);
1467 return nativeResponseValue;
1470 export function LDKCOption_CVec_ThirtyTwoBytesZZ_Some_get_some(ptr: bigint): number {
1471 if(!isWasmInitialized) {
1472 throw new Error("initializeWasm() must be awaited first!");
1474 const nativeResponseValue = wasm.TS_LDKCOption_CVec_ThirtyTwoBytesZZ_Some_get_some(ptr);
1475 return nativeResponseValue;
1477 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesNoneZ_get_ok(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR owner);
1479 export function CResult_ThirtyTwoBytesNoneZ_get_ok(owner: bigint): number {
1480 if(!isWasmInitialized) {
1481 throw new Error("initializeWasm() must be awaited first!");
1483 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_get_ok(owner);
1484 return nativeResponseValue;
1486 // void CResult_ThirtyTwoBytesNoneZ_get_err(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR owner);
1488 export function CResult_ThirtyTwoBytesNoneZ_get_err(owner: bigint): void {
1489 if(!isWasmInitialized) {
1490 throw new Error("initializeWasm() must be awaited first!");
1492 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_get_err(owner);
1493 // debug statements here
1495 // struct LDKBlindedPayInfo CResult_BlindedPayInfoDecodeErrorZ_get_ok(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
1497 export function CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
1498 if(!isWasmInitialized) {
1499 throw new Error("initializeWasm() must be awaited first!");
1501 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner);
1502 return nativeResponseValue;
1504 // struct LDKDecodeError CResult_BlindedPayInfoDecodeErrorZ_get_err(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
1506 export function CResult_BlindedPayInfoDecodeErrorZ_get_err(owner: bigint): bigint {
1507 if(!isWasmInitialized) {
1508 throw new Error("initializeWasm() must be awaited first!");
1510 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_err(owner);
1511 return nativeResponseValue;
1513 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1515 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1516 if(!isWasmInitialized) {
1517 throw new Error("initializeWasm() must be awaited first!");
1519 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
1520 return nativeResponseValue;
1522 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1524 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1525 if(!isWasmInitialized) {
1526 throw new Error("initializeWasm() must be awaited first!");
1528 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
1529 return nativeResponseValue;
1531 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1533 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1534 if(!isWasmInitialized) {
1535 throw new Error("initializeWasm() must be awaited first!");
1537 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
1538 return nativeResponseValue;
1540 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1542 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1543 if(!isWasmInitialized) {
1544 throw new Error("initializeWasm() must be awaited first!");
1546 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
1547 return nativeResponseValue;
1550 export class LDKSpendableOutputDescriptor {
1551 protected constructor() {}
1554 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
1555 if(!isWasmInitialized) {
1556 throw new Error("initializeWasm() must be awaited first!");
1558 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1559 return nativeResponseValue;
1562 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
1563 if(!isWasmInitialized) {
1564 throw new Error("initializeWasm() must be awaited first!");
1566 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1567 return nativeResponseValue;
1570 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
1571 if(!isWasmInitialized) {
1572 throw new Error("initializeWasm() must be awaited first!");
1574 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1575 return nativeResponseValue;
1578 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
1579 if(!isWasmInitialized) {
1580 throw new Error("initializeWasm() must be awaited first!");
1582 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1583 return nativeResponseValue;
1586 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
1587 if(!isWasmInitialized) {
1588 throw new Error("initializeWasm() must be awaited first!");
1590 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1591 return nativeResponseValue;
1593 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1595 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1596 if(!isWasmInitialized) {
1597 throw new Error("initializeWasm() must be awaited first!");
1599 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
1600 return nativeResponseValue;
1602 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1604 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1605 if(!isWasmInitialized) {
1606 throw new Error("initializeWasm() must be awaited first!");
1608 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
1609 return nativeResponseValue;
1612 export class LDKCOption_u32Z {
1613 protected constructor() {}
1616 export function LDKCOption_u32Z_ty_from_ptr(ptr: bigint): number {
1617 if(!isWasmInitialized) {
1618 throw new Error("initializeWasm() must be awaited first!");
1620 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
1621 return nativeResponseValue;
1624 export function LDKCOption_u32Z_Some_get_some(ptr: bigint): number {
1625 if(!isWasmInitialized) {
1626 throw new Error("initializeWasm() must be awaited first!");
1628 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
1629 return nativeResponseValue;
1631 // struct LDKCVec_u8Z C2Tuple_CVec_u8ZusizeZ_get_a(LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR owner);
1633 export function C2Tuple_CVec_u8ZusizeZ_get_a(owner: bigint): number {
1634 if(!isWasmInitialized) {
1635 throw new Error("initializeWasm() must be awaited first!");
1637 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_get_a(owner);
1638 return nativeResponseValue;
1640 // uintptr_t C2Tuple_CVec_u8ZusizeZ_get_b(LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR owner);
1642 export function C2Tuple_CVec_u8ZusizeZ_get_b(owner: bigint): number {
1643 if(!isWasmInitialized) {
1644 throw new Error("initializeWasm() must be awaited first!");
1646 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_get_b(owner);
1647 return nativeResponseValue;
1649 // struct LDKC2Tuple_CVec_u8ZusizeZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_ok(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR owner);
1651 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_ok(owner: bigint): bigint {
1652 if(!isWasmInitialized) {
1653 throw new Error("initializeWasm() must be awaited first!");
1655 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_ok(owner);
1656 return nativeResponseValue;
1658 // void CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_err(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR owner);
1660 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_err(owner: bigint): void {
1661 if(!isWasmInitialized) {
1662 throw new Error("initializeWasm() must be awaited first!");
1664 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_err(owner);
1665 // debug statements here
1667 // struct LDKChannelDerivationParameters CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR owner);
1669 export function CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1670 if(!isWasmInitialized) {
1671 throw new Error("initializeWasm() must be awaited first!");
1673 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(owner);
1674 return nativeResponseValue;
1676 // struct LDKDecodeError CResult_ChannelDerivationParametersDecodeErrorZ_get_err(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR owner);
1678 export function CResult_ChannelDerivationParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1679 if(!isWasmInitialized) {
1680 throw new Error("initializeWasm() must be awaited first!");
1682 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_err(owner);
1683 return nativeResponseValue;
1685 // struct LDKHTLCDescriptor CResult_HTLCDescriptorDecodeErrorZ_get_ok(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR owner);
1687 export function CResult_HTLCDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1688 if(!isWasmInitialized) {
1689 throw new Error("initializeWasm() must be awaited first!");
1691 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_get_ok(owner);
1692 return nativeResponseValue;
1694 // struct LDKDecodeError CResult_HTLCDescriptorDecodeErrorZ_get_err(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR owner);
1696 export function CResult_HTLCDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1697 if(!isWasmInitialized) {
1698 throw new Error("initializeWasm() must be awaited first!");
1700 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_get_err(owner);
1701 return nativeResponseValue;
1703 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1705 export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
1706 if(!isWasmInitialized) {
1707 throw new Error("initializeWasm() must be awaited first!");
1709 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
1710 // debug statements here
1712 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1714 export function CResult_NoneNoneZ_get_err(owner: bigint): void {
1715 if(!isWasmInitialized) {
1716 throw new Error("initializeWasm() must be awaited first!");
1718 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
1719 // debug statements here
1721 // struct LDKECDSASignature C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR owner);
1723 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(owner: bigint): number {
1724 if(!isWasmInitialized) {
1725 throw new Error("initializeWasm() must be awaited first!");
1727 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(owner);
1728 return nativeResponseValue;
1730 // struct LDKCVec_ECDSASignatureZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR owner);
1732 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(owner: bigint): number {
1733 if(!isWasmInitialized) {
1734 throw new Error("initializeWasm() must be awaited first!");
1736 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(owner);
1737 return nativeResponseValue;
1739 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR owner);
1741 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(owner: bigint): bigint {
1742 if(!isWasmInitialized) {
1743 throw new Error("initializeWasm() must be awaited first!");
1745 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(owner);
1746 return nativeResponseValue;
1748 // void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR owner);
1750 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(owner: bigint): void {
1751 if(!isWasmInitialized) {
1752 throw new Error("initializeWasm() must be awaited first!");
1754 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(owner);
1755 // debug statements here
1757 // struct LDKECDSASignature CResult_ECDSASignatureNoneZ_get_ok(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR owner);
1759 export function CResult_ECDSASignatureNoneZ_get_ok(owner: bigint): number {
1760 if(!isWasmInitialized) {
1761 throw new Error("initializeWasm() must be awaited first!");
1763 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_get_ok(owner);
1764 return nativeResponseValue;
1766 // void CResult_ECDSASignatureNoneZ_get_err(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR owner);
1768 export function CResult_ECDSASignatureNoneZ_get_err(owner: bigint): void {
1769 if(!isWasmInitialized) {
1770 throw new Error("initializeWasm() must be awaited first!");
1772 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_get_err(owner);
1773 // debug statements here
1775 // struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
1777 export function CResult_PublicKeyNoneZ_get_ok(owner: bigint): number {
1778 if(!isWasmInitialized) {
1779 throw new Error("initializeWasm() must be awaited first!");
1781 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_ok(owner);
1782 return nativeResponseValue;
1784 // void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
1786 export function CResult_PublicKeyNoneZ_get_err(owner: bigint): void {
1787 if(!isWasmInitialized) {
1788 throw new Error("initializeWasm() must be awaited first!");
1790 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_err(owner);
1791 // debug statements here
1794 export class LDKCOption_BigEndianScalarZ {
1795 protected constructor() {}
1798 export function LDKCOption_BigEndianScalarZ_ty_from_ptr(ptr: bigint): number {
1799 if(!isWasmInitialized) {
1800 throw new Error("initializeWasm() must be awaited first!");
1802 const nativeResponseValue = wasm.TS_LDKCOption_BigEndianScalarZ_ty_from_ptr(ptr);
1803 return nativeResponseValue;
1806 export function LDKCOption_BigEndianScalarZ_Some_get_some(ptr: bigint): bigint {
1807 if(!isWasmInitialized) {
1808 throw new Error("initializeWasm() must be awaited first!");
1810 const nativeResponseValue = wasm.TS_LDKCOption_BigEndianScalarZ_Some_get_some(ptr);
1811 return nativeResponseValue;
1813 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
1815 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: bigint): number {
1816 if(!isWasmInitialized) {
1817 throw new Error("initializeWasm() must be awaited first!");
1819 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
1820 return nativeResponseValue;
1822 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
1824 export function CResult_RecoverableSignatureNoneZ_get_err(owner: bigint): void {
1825 if(!isWasmInitialized) {
1826 throw new Error("initializeWasm() must be awaited first!");
1828 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
1829 // debug statements here
1831 // struct LDKSchnorrSignature CResult_SchnorrSignatureNoneZ_get_ok(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR owner);
1833 export function CResult_SchnorrSignatureNoneZ_get_ok(owner: bigint): number {
1834 if(!isWasmInitialized) {
1835 throw new Error("initializeWasm() must be awaited first!");
1837 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_get_ok(owner);
1838 return nativeResponseValue;
1840 // void CResult_SchnorrSignatureNoneZ_get_err(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR owner);
1842 export function CResult_SchnorrSignatureNoneZ_get_err(owner: bigint): void {
1843 if(!isWasmInitialized) {
1844 throw new Error("initializeWasm() must be awaited first!");
1846 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_get_err(owner);
1847 // debug statements here
1850 export interface LDKChannelSigner {
1851 get_per_commitment_point (idx: bigint): number;
1852 release_commitment_secret (idx: bigint): number;
1853 validate_holder_commitment (holder_tx: bigint, preimages: number): bigint;
1854 channel_keys_id (): number;
1855 provide_channel_parameters (channel_parameters: bigint): void;
1859 export function LDKChannelSigner_new(impl: LDKChannelSigner, pubkeys: bigint): [bigint, number] {
1860 if(!isWasmInitialized) {
1861 throw new Error("initializeWasm() must be awaited first!");
1863 var new_obj_idx = js_objs.length;
1864 for (var i = 0; i < js_objs.length; i++) {
1865 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1867 js_objs[i] = new WeakRef(impl);
1868 return [wasm.TS_LDKChannelSigner_new(i, pubkeys), i];
1870 // LDKPublicKey ChannelSigner_get_per_commitment_point LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
1872 export function ChannelSigner_get_per_commitment_point(this_arg: bigint, idx: bigint): number {
1873 if(!isWasmInitialized) {
1874 throw new Error("initializeWasm() must be awaited first!");
1876 const nativeResponseValue = wasm.TS_ChannelSigner_get_per_commitment_point(this_arg, idx);
1877 return nativeResponseValue;
1879 // LDKThirtyTwoBytes ChannelSigner_release_commitment_secret LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
1881 export function ChannelSigner_release_commitment_secret(this_arg: bigint, idx: bigint): number {
1882 if(!isWasmInitialized) {
1883 throw new Error("initializeWasm() must be awaited first!");
1885 const nativeResponseValue = wasm.TS_ChannelSigner_release_commitment_secret(this_arg, idx);
1886 return nativeResponseValue;
1888 // LDKCResult_NoneNoneZ ChannelSigner_validate_holder_commitment LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ preimages
1890 export function ChannelSigner_validate_holder_commitment(this_arg: bigint, holder_tx: bigint, preimages: number): bigint {
1891 if(!isWasmInitialized) {
1892 throw new Error("initializeWasm() must be awaited first!");
1894 const nativeResponseValue = wasm.TS_ChannelSigner_validate_holder_commitment(this_arg, holder_tx, preimages);
1895 return nativeResponseValue;
1897 // LDKThirtyTwoBytes ChannelSigner_channel_keys_id LDKChannelSigner *NONNULL_PTR this_arg
1899 export function ChannelSigner_channel_keys_id(this_arg: bigint): number {
1900 if(!isWasmInitialized) {
1901 throw new Error("initializeWasm() must be awaited first!");
1903 const nativeResponseValue = wasm.TS_ChannelSigner_channel_keys_id(this_arg);
1904 return nativeResponseValue;
1906 // void ChannelSigner_provide_channel_parameters LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
1908 export function ChannelSigner_provide_channel_parameters(this_arg: bigint, channel_parameters: bigint): void {
1909 if(!isWasmInitialized) {
1910 throw new Error("initializeWasm() must be awaited first!");
1912 const nativeResponseValue = wasm.TS_ChannelSigner_provide_channel_parameters(this_arg, channel_parameters);
1913 // debug statements here
1915 // LDKChannelPublicKeys ChannelSigner_get_pubkeys LDKChannelSigner *NONNULL_PTR this_arg
1917 export function ChannelSigner_get_pubkeys(this_arg: bigint): bigint {
1918 if(!isWasmInitialized) {
1919 throw new Error("initializeWasm() must be awaited first!");
1921 const nativeResponseValue = wasm.TS_ChannelSigner_get_pubkeys(this_arg);
1922 return nativeResponseValue;
1925 export interface LDKEcdsaChannelSigner {
1926 sign_counterparty_commitment (commitment_tx: bigint, preimages: number): bigint;
1927 validate_counterparty_revocation (idx: bigint, secret: number): bigint;
1928 sign_holder_commitment (commitment_tx: bigint): bigint;
1929 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint;
1930 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint;
1931 sign_holder_htlc_transaction (htlc_tx: number, input: number, htlc_descriptor: bigint): bigint;
1932 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint;
1933 sign_closing_transaction (closing_tx: bigint): bigint;
1934 sign_holder_anchor_input (anchor_tx: number, input: number): bigint;
1935 sign_channel_announcement_with_funding_key (msg: bigint): bigint;
1939 export function LDKEcdsaChannelSigner_new(impl: LDKEcdsaChannelSigner, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
1940 if(!isWasmInitialized) {
1941 throw new Error("initializeWasm() must be awaited first!");
1943 var new_obj_idx = js_objs.length;
1944 for (var i = 0; i < js_objs.length; i++) {
1945 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1947 js_objs[i] = new WeakRef(impl);
1948 return [wasm.TS_LDKEcdsaChannelSigner_new(i, ChannelSigner, pubkeys), i];
1950 // LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner_sign_counterparty_commitment LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ preimages
1952 export function EcdsaChannelSigner_sign_counterparty_commitment(this_arg: bigint, commitment_tx: bigint, preimages: number): bigint {
1953 if(!isWasmInitialized) {
1954 throw new Error("initializeWasm() must be awaited first!");
1956 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
1957 return nativeResponseValue;
1959 // LDKCResult_NoneNoneZ EcdsaChannelSigner_validate_counterparty_revocation LDKEcdsaChannelSigner *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
1961 export function EcdsaChannelSigner_validate_counterparty_revocation(this_arg: bigint, idx: bigint, secret: number): bigint {
1962 if(!isWasmInitialized) {
1963 throw new Error("initializeWasm() must be awaited first!");
1965 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_validate_counterparty_revocation(this_arg, idx, secret);
1966 return nativeResponseValue;
1968 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_holder_commitment LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
1970 export function EcdsaChannelSigner_sign_holder_commitment(this_arg: bigint, commitment_tx: bigint): bigint {
1971 if(!isWasmInitialized) {
1972 throw new Error("initializeWasm() must be awaited first!");
1974 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_commitment(this_arg, commitment_tx);
1975 return nativeResponseValue;
1977 // 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]
1979 export function EcdsaChannelSigner_sign_justice_revoked_output(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint {
1980 if(!isWasmInitialized) {
1981 throw new Error("initializeWasm() must be awaited first!");
1983 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
1984 return nativeResponseValue;
1986 // 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
1988 export function EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint {
1989 if(!isWasmInitialized) {
1990 throw new Error("initializeWasm() must be awaited first!");
1992 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
1993 return nativeResponseValue;
1995 // 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
1997 export function EcdsaChannelSigner_sign_holder_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, htlc_descriptor: bigint): bigint {
1998 if(!isWasmInitialized) {
1999 throw new Error("initializeWasm() must be awaited first!");
2001 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_htlc_transaction(this_arg, htlc_tx, input, htlc_descriptor);
2002 return nativeResponseValue;
2004 // 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
2006 export function EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint {
2007 if(!isWasmInitialized) {
2008 throw new Error("initializeWasm() must be awaited first!");
2010 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
2011 return nativeResponseValue;
2013 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_closing_transaction LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
2015 export function EcdsaChannelSigner_sign_closing_transaction(this_arg: bigint, closing_tx: bigint): bigint {
2016 if(!isWasmInitialized) {
2017 throw new Error("initializeWasm() must be awaited first!");
2019 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_closing_transaction(this_arg, closing_tx);
2020 return nativeResponseValue;
2022 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_holder_anchor_input LDKEcdsaChannelSigner *NONNULL_PTR this_arg, struct LDKTransaction anchor_tx, uintptr_t input
2024 export function EcdsaChannelSigner_sign_holder_anchor_input(this_arg: bigint, anchor_tx: number, input: number): bigint {
2025 if(!isWasmInitialized) {
2026 throw new Error("initializeWasm() must be awaited first!");
2028 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_anchor_input(this_arg, anchor_tx, input);
2029 return nativeResponseValue;
2031 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_channel_announcement_with_funding_key LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
2033 export function EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg: bigint, msg: bigint): bigint {
2034 if(!isWasmInitialized) {
2035 throw new Error("initializeWasm() must be awaited first!");
2037 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg, msg);
2038 return nativeResponseValue;
2041 export interface LDKWriteableEcdsaChannelSigner {
2046 export function LDKWriteableEcdsaChannelSigner_new(impl: LDKWriteableEcdsaChannelSigner, EcdsaChannelSigner: number, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
2047 if(!isWasmInitialized) {
2048 throw new Error("initializeWasm() must be awaited first!");
2050 var new_obj_idx = js_objs.length;
2051 for (var i = 0; i < js_objs.length; i++) {
2052 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2054 js_objs[i] = new WeakRef(impl);
2055 return [wasm.TS_LDKWriteableEcdsaChannelSigner_new(i, EcdsaChannelSigner, ChannelSigner, pubkeys), i];
2057 // LDKCVec_u8Z WriteableEcdsaChannelSigner_write LDKWriteableEcdsaChannelSigner *NONNULL_PTR this_arg
2059 export function WriteableEcdsaChannelSigner_write(this_arg: bigint): number {
2060 if(!isWasmInitialized) {
2061 throw new Error("initializeWasm() must be awaited first!");
2063 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_write(this_arg);
2064 return nativeResponseValue;
2066 // struct LDKWriteableEcdsaChannelSigner CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
2068 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner: bigint): bigint {
2069 if(!isWasmInitialized) {
2070 throw new Error("initializeWasm() must be awaited first!");
2072 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner);
2073 return nativeResponseValue;
2075 // struct LDKDecodeError CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
2077 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner: bigint): bigint {
2078 if(!isWasmInitialized) {
2079 throw new Error("initializeWasm() must be awaited first!");
2081 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner);
2082 return nativeResponseValue;
2084 // struct LDKCVec_u8Z CResult_CVec_u8ZNoneZ_get_ok(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR owner);
2086 export function CResult_CVec_u8ZNoneZ_get_ok(owner: bigint): number {
2087 if(!isWasmInitialized) {
2088 throw new Error("initializeWasm() must be awaited first!");
2090 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_get_ok(owner);
2091 return nativeResponseValue;
2093 // void CResult_CVec_u8ZNoneZ_get_err(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR owner);
2095 export function CResult_CVec_u8ZNoneZ_get_err(owner: bigint): void {
2096 if(!isWasmInitialized) {
2097 throw new Error("initializeWasm() must be awaited first!");
2099 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_get_err(owner);
2100 // debug statements here
2102 // struct LDKShutdownScript CResult_ShutdownScriptNoneZ_get_ok(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner);
2104 export function CResult_ShutdownScriptNoneZ_get_ok(owner: bigint): bigint {
2105 if(!isWasmInitialized) {
2106 throw new Error("initializeWasm() must be awaited first!");
2108 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_get_ok(owner);
2109 return nativeResponseValue;
2111 // void CResult_ShutdownScriptNoneZ_get_err(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner);
2113 export function CResult_ShutdownScriptNoneZ_get_err(owner: bigint): void {
2114 if(!isWasmInitialized) {
2115 throw new Error("initializeWasm() must be awaited first!");
2117 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_get_err(owner);
2118 // debug statements here
2121 export class LDKCOption_u16Z {
2122 protected constructor() {}
2125 export function LDKCOption_u16Z_ty_from_ptr(ptr: bigint): number {
2126 if(!isWasmInitialized) {
2127 throw new Error("initializeWasm() must be awaited first!");
2129 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
2130 return nativeResponseValue;
2133 export function LDKCOption_u16Z_Some_get_some(ptr: bigint): number {
2134 if(!isWasmInitialized) {
2135 throw new Error("initializeWasm() must be awaited first!");
2137 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
2138 return nativeResponseValue;
2141 export class LDKCOption_boolZ {
2142 protected constructor() {}
2145 export function LDKCOption_boolZ_ty_from_ptr(ptr: bigint): number {
2146 if(!isWasmInitialized) {
2147 throw new Error("initializeWasm() must be awaited first!");
2149 const nativeResponseValue = wasm.TS_LDKCOption_boolZ_ty_from_ptr(ptr);
2150 return nativeResponseValue;
2153 export function LDKCOption_boolZ_Some_get_some(ptr: bigint): boolean {
2154 if(!isWasmInitialized) {
2155 throw new Error("initializeWasm() must be awaited first!");
2157 const nativeResponseValue = wasm.TS_LDKCOption_boolZ_Some_get_some(ptr);
2158 return nativeResponseValue;
2160 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2162 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: bigint): number {
2163 if(!isWasmInitialized) {
2164 throw new Error("initializeWasm() must be awaited first!");
2166 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
2167 return nativeResponseValue;
2169 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2171 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: bigint): void {
2172 if(!isWasmInitialized) {
2173 throw new Error("initializeWasm() must be awaited first!");
2175 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
2176 // debug statements here
2178 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2180 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: bigint): bigint {
2181 if(!isWasmInitialized) {
2182 throw new Error("initializeWasm() must be awaited first!");
2184 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
2185 return nativeResponseValue;
2187 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2189 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: bigint): bigint {
2190 if(!isWasmInitialized) {
2191 throw new Error("initializeWasm() must be awaited first!");
2193 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
2194 return nativeResponseValue;
2196 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2198 export function CResult_TransactionNoneZ_get_ok(owner: bigint): number {
2199 if(!isWasmInitialized) {
2200 throw new Error("initializeWasm() must be awaited first!");
2202 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
2203 return nativeResponseValue;
2205 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2207 export function CResult_TransactionNoneZ_get_err(owner: bigint): void {
2208 if(!isWasmInitialized) {
2209 throw new Error("initializeWasm() must be awaited first!");
2211 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
2212 // debug statements here
2214 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2216 export function CResult_RouteLightningErrorZ_get_ok(owner: bigint): bigint {
2217 if(!isWasmInitialized) {
2218 throw new Error("initializeWasm() must be awaited first!");
2220 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
2221 return nativeResponseValue;
2223 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2225 export function CResult_RouteLightningErrorZ_get_err(owner: bigint): bigint {
2226 if(!isWasmInitialized) {
2227 throw new Error("initializeWasm() must be awaited first!");
2229 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
2230 return nativeResponseValue;
2232 // struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
2234 export function CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner: bigint): bigint {
2235 if(!isWasmInitialized) {
2236 throw new Error("initializeWasm() must be awaited first!");
2238 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner);
2239 return nativeResponseValue;
2241 // struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
2243 export function CResult_InFlightHtlcsDecodeErrorZ_get_err(owner: bigint): bigint {
2244 if(!isWasmInitialized) {
2245 throw new Error("initializeWasm() must be awaited first!");
2247 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(owner);
2248 return nativeResponseValue;
2250 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
2252 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: bigint): bigint {
2253 if(!isWasmInitialized) {
2254 throw new Error("initializeWasm() must be awaited first!");
2256 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
2257 return nativeResponseValue;
2259 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
2261 export function CResult_RouteHopDecodeErrorZ_get_err(owner: bigint): bigint {
2262 if(!isWasmInitialized) {
2263 throw new Error("initializeWasm() must be awaited first!");
2265 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
2266 return nativeResponseValue;
2268 // struct LDKBlindedTail CResult_BlindedTailDecodeErrorZ_get_ok(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
2270 export function CResult_BlindedTailDecodeErrorZ_get_ok(owner: bigint): bigint {
2271 if(!isWasmInitialized) {
2272 throw new Error("initializeWasm() must be awaited first!");
2274 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_ok(owner);
2275 return nativeResponseValue;
2277 // struct LDKDecodeError CResult_BlindedTailDecodeErrorZ_get_err(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
2279 export function CResult_BlindedTailDecodeErrorZ_get_err(owner: bigint): bigint {
2280 if(!isWasmInitialized) {
2281 throw new Error("initializeWasm() must be awaited first!");
2283 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_err(owner);
2284 return nativeResponseValue;
2286 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
2288 export function CResult_RouteDecodeErrorZ_get_ok(owner: bigint): bigint {
2289 if(!isWasmInitialized) {
2290 throw new Error("initializeWasm() must be awaited first!");
2292 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
2293 return nativeResponseValue;
2295 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
2297 export function CResult_RouteDecodeErrorZ_get_err(owner: bigint): bigint {
2298 if(!isWasmInitialized) {
2299 throw new Error("initializeWasm() must be awaited first!");
2301 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
2302 return nativeResponseValue;
2304 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
2306 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
2307 if(!isWasmInitialized) {
2308 throw new Error("initializeWasm() must be awaited first!");
2310 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
2311 return nativeResponseValue;
2313 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
2315 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: bigint): bigint {
2316 if(!isWasmInitialized) {
2317 throw new Error("initializeWasm() must be awaited first!");
2319 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
2320 return nativeResponseValue;
2322 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
2324 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
2325 if(!isWasmInitialized) {
2326 throw new Error("initializeWasm() must be awaited first!");
2328 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
2329 return nativeResponseValue;
2331 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
2333 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: bigint): bigint {
2334 if(!isWasmInitialized) {
2335 throw new Error("initializeWasm() must be awaited first!");
2337 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
2338 return nativeResponseValue;
2340 // struct LDKBlindedPayInfo C2Tuple_BlindedPayInfoBlindedPathZ_get_a(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
2342 export function C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner: bigint): bigint {
2343 if(!isWasmInitialized) {
2344 throw new Error("initializeWasm() must be awaited first!");
2346 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner);
2347 return nativeResponseValue;
2349 // struct LDKBlindedPath C2Tuple_BlindedPayInfoBlindedPathZ_get_b(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
2351 export function C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner: bigint): bigint {
2352 if(!isWasmInitialized) {
2353 throw new Error("initializeWasm() must be awaited first!");
2355 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner);
2356 return nativeResponseValue;
2358 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2360 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: bigint): bigint {
2361 if(!isWasmInitialized) {
2362 throw new Error("initializeWasm() must be awaited first!");
2364 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
2365 return nativeResponseValue;
2367 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2369 export function CResult_RouteHintDecodeErrorZ_get_err(owner: bigint): bigint {
2370 if(!isWasmInitialized) {
2371 throw new Error("initializeWasm() must be awaited first!");
2373 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
2374 return nativeResponseValue;
2376 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2378 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: bigint): bigint {
2379 if(!isWasmInitialized) {
2380 throw new Error("initializeWasm() must be awaited first!");
2382 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
2383 return nativeResponseValue;
2385 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2387 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: bigint): bigint {
2388 if(!isWasmInitialized) {
2389 throw new Error("initializeWasm() must be awaited first!");
2391 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
2392 return nativeResponseValue;
2394 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2396 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2397 if(!isWasmInitialized) {
2398 throw new Error("initializeWasm() must be awaited first!");
2400 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2401 return nativeResponseValue;
2403 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2405 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2406 if(!isWasmInitialized) {
2407 throw new Error("initializeWasm() must be awaited first!");
2409 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2410 return nativeResponseValue;
2412 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2414 export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
2415 if(!isWasmInitialized) {
2416 throw new Error("initializeWasm() must be awaited first!");
2418 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2419 return nativeResponseValue;
2421 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2423 export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
2424 if(!isWasmInitialized) {
2425 throw new Error("initializeWasm() must be awaited first!");
2427 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2428 return nativeResponseValue;
2431 export class LDKCOption_C2Tuple_u64u64ZZ {
2432 protected constructor() {}
2435 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
2436 if(!isWasmInitialized) {
2437 throw new Error("initializeWasm() must be awaited first!");
2439 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2440 return nativeResponseValue;
2443 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
2444 if(!isWasmInitialized) {
2445 throw new Error("initializeWasm() must be awaited first!");
2447 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2448 return nativeResponseValue;
2450 // struct LDKThirtyTwoU16s C2Tuple_Z_get_a(LDKC2Tuple_Z *NONNULL_PTR owner);
2452 export function C2Tuple_Z_get_a(owner: bigint): number {
2453 if(!isWasmInitialized) {
2454 throw new Error("initializeWasm() must be awaited first!");
2456 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_a(owner);
2457 return nativeResponseValue;
2459 // struct LDKThirtyTwoU16s C2Tuple_Z_get_b(LDKC2Tuple_Z *NONNULL_PTR owner);
2461 export function C2Tuple_Z_get_b(owner: bigint): number {
2462 if(!isWasmInitialized) {
2463 throw new Error("initializeWasm() must be awaited first!");
2465 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_b(owner);
2466 return nativeResponseValue;
2468 // struct LDKThirtyTwoU16s C2Tuple__u1632_u1632Z_get_a(LDKC2Tuple__u1632_u1632Z *NONNULL_PTR owner);
2470 export function C2Tuple__u1632_u1632Z_get_a(owner: bigint): number {
2471 if(!isWasmInitialized) {
2472 throw new Error("initializeWasm() must be awaited first!");
2474 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_get_a(owner);
2475 return nativeResponseValue;
2477 // struct LDKThirtyTwoU16s C2Tuple__u1632_u1632Z_get_b(LDKC2Tuple__u1632_u1632Z *NONNULL_PTR owner);
2479 export function C2Tuple__u1632_u1632Z_get_b(owner: bigint): number {
2480 if(!isWasmInitialized) {
2481 throw new Error("initializeWasm() must be awaited first!");
2483 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_get_b(owner);
2484 return nativeResponseValue;
2487 export class LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ {
2488 protected constructor() {}
2491 export function LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_ty_from_ptr(ptr: bigint): number {
2492 if(!isWasmInitialized) {
2493 throw new Error("initializeWasm() must be awaited first!");
2495 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_ty_from_ptr(ptr);
2496 return nativeResponseValue;
2499 export function LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some_get_some(ptr: bigint): bigint {
2500 if(!isWasmInitialized) {
2501 throw new Error("initializeWasm() must be awaited first!");
2503 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some_get_some(ptr);
2504 return nativeResponseValue;
2507 export class LDKCOption_f64Z {
2508 protected constructor() {}
2511 export function LDKCOption_f64Z_ty_from_ptr(ptr: bigint): number {
2512 if(!isWasmInitialized) {
2513 throw new Error("initializeWasm() must be awaited first!");
2515 const nativeResponseValue = wasm.TS_LDKCOption_f64Z_ty_from_ptr(ptr);
2516 return nativeResponseValue;
2519 export function LDKCOption_f64Z_Some_get_some(ptr: bigint): number {
2520 if(!isWasmInitialized) {
2521 throw new Error("initializeWasm() must be awaited first!");
2523 const nativeResponseValue = wasm.TS_LDKCOption_f64Z_Some_get_some(ptr);
2524 return nativeResponseValue;
2527 export interface LDKLogger {
2528 log (record: bigint): void;
2532 export function LDKLogger_new(impl: LDKLogger): [bigint, number] {
2533 if(!isWasmInitialized) {
2534 throw new Error("initializeWasm() must be awaited first!");
2536 var new_obj_idx = js_objs.length;
2537 for (var i = 0; i < js_objs.length; i++) {
2538 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2540 js_objs[i] = new WeakRef(impl);
2541 return [wasm.TS_LDKLogger_new(i), i];
2543 // struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2545 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2546 if(!isWasmInitialized) {
2547 throw new Error("initializeWasm() must be awaited first!");
2549 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2550 return nativeResponseValue;
2552 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2554 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2555 if(!isWasmInitialized) {
2556 throw new Error("initializeWasm() must be awaited first!");
2558 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2559 return nativeResponseValue;
2561 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2563 export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
2564 if(!isWasmInitialized) {
2565 throw new Error("initializeWasm() must be awaited first!");
2567 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2568 return nativeResponseValue;
2570 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2572 export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
2573 if(!isWasmInitialized) {
2574 throw new Error("initializeWasm() must be awaited first!");
2576 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2577 return nativeResponseValue;
2579 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR owner);
2581 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_a(owner: bigint): number {
2582 if(!isWasmInitialized) {
2583 throw new Error("initializeWasm() must be awaited first!");
2585 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_a(owner);
2586 return nativeResponseValue;
2588 // struct LDKCOption_ThirtyTwoBytesZ C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR owner);
2590 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_b(owner: bigint): bigint {
2591 if(!isWasmInitialized) {
2592 throw new Error("initializeWasm() must be awaited first!");
2594 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_b(owner);
2595 return nativeResponseValue;
2597 // enum LDKChannelMonitorUpdateStatus CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR owner);
2599 export function CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(owner: bigint): ChannelMonitorUpdateStatus {
2600 if(!isWasmInitialized) {
2601 throw new Error("initializeWasm() must be awaited first!");
2603 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(owner);
2604 return nativeResponseValue;
2606 // void CResult_ChannelMonitorUpdateStatusNoneZ_get_err(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR owner);
2608 export function CResult_ChannelMonitorUpdateStatusNoneZ_get_err(owner: bigint): void {
2609 if(!isWasmInitialized) {
2610 throw new Error("initializeWasm() must be awaited first!");
2612 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_err(owner);
2613 // debug statements here
2616 export class LDKMonitorEvent {
2617 protected constructor() {}
2620 export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
2621 if(!isWasmInitialized) {
2622 throw new Error("initializeWasm() must be awaited first!");
2624 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2625 return nativeResponseValue;
2628 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
2629 if(!isWasmInitialized) {
2630 throw new Error("initializeWasm() must be awaited first!");
2632 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2633 return nativeResponseValue;
2636 export function LDKMonitorEvent_HolderForceClosed_get_holder_force_closed(ptr: bigint): bigint {
2637 if(!isWasmInitialized) {
2638 throw new Error("initializeWasm() must be awaited first!");
2640 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HolderForceClosed_get_holder_force_closed(ptr);
2641 return nativeResponseValue;
2644 export function LDKMonitorEvent_Completed_get_funding_txo(ptr: bigint): bigint {
2645 if(!isWasmInitialized) {
2646 throw new Error("initializeWasm() must be awaited first!");
2648 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_funding_txo(ptr);
2649 return nativeResponseValue;
2652 export function LDKMonitorEvent_Completed_get_monitor_update_id(ptr: bigint): bigint {
2653 if(!isWasmInitialized) {
2654 throw new Error("initializeWasm() must be awaited first!");
2656 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_monitor_update_id(ptr);
2657 return nativeResponseValue;
2659 // struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2661 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
2662 if(!isWasmInitialized) {
2663 throw new Error("initializeWasm() must be awaited first!");
2665 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
2666 return nativeResponseValue;
2668 // struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2670 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): number {
2671 if(!isWasmInitialized) {
2672 throw new Error("initializeWasm() must be awaited first!");
2674 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
2675 return nativeResponseValue;
2677 // struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2679 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
2680 if(!isWasmInitialized) {
2681 throw new Error("initializeWasm() must be awaited first!");
2683 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
2684 return nativeResponseValue;
2686 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2688 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2689 if(!isWasmInitialized) {
2690 throw new Error("initializeWasm() must be awaited first!");
2692 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2693 return nativeResponseValue;
2695 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2697 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2698 if(!isWasmInitialized) {
2699 throw new Error("initializeWasm() must be awaited first!");
2701 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2702 return nativeResponseValue;
2704 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2706 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2707 if(!isWasmInitialized) {
2708 throw new Error("initializeWasm() must be awaited first!");
2710 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2711 return nativeResponseValue;
2713 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2715 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2716 if(!isWasmInitialized) {
2717 throw new Error("initializeWasm() must be awaited first!");
2719 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2720 return nativeResponseValue;
2722 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2724 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2725 if(!isWasmInitialized) {
2726 throw new Error("initializeWasm() must be awaited first!");
2728 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2729 return nativeResponseValue;
2731 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2733 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2734 if(!isWasmInitialized) {
2735 throw new Error("initializeWasm() must be awaited first!");
2737 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2738 return nativeResponseValue;
2740 // struct LDKBolt11InvoiceFeatures CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2742 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2743 if(!isWasmInitialized) {
2744 throw new Error("initializeWasm() must be awaited first!");
2746 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2747 return nativeResponseValue;
2749 // struct LDKDecodeError CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2751 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2752 if(!isWasmInitialized) {
2753 throw new Error("initializeWasm() must be awaited first!");
2755 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(owner);
2756 return nativeResponseValue;
2758 // struct LDKBolt12InvoiceFeatures CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2760 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2761 if(!isWasmInitialized) {
2762 throw new Error("initializeWasm() must be awaited first!");
2764 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2765 return nativeResponseValue;
2767 // struct LDKDecodeError CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2769 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2770 if(!isWasmInitialized) {
2771 throw new Error("initializeWasm() must be awaited first!");
2773 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(owner);
2774 return nativeResponseValue;
2776 // struct LDKBlindedHopFeatures CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
2778 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2779 if(!isWasmInitialized) {
2780 throw new Error("initializeWasm() must be awaited first!");
2782 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner);
2783 return nativeResponseValue;
2785 // struct LDKDecodeError CResult_BlindedHopFeaturesDecodeErrorZ_get_err(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
2787 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2788 if(!isWasmInitialized) {
2789 throw new Error("initializeWasm() must be awaited first!");
2791 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner);
2792 return nativeResponseValue;
2794 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2796 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2797 if(!isWasmInitialized) {
2798 throw new Error("initializeWasm() must be awaited first!");
2800 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2801 return nativeResponseValue;
2803 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2805 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2806 if(!isWasmInitialized) {
2807 throw new Error("initializeWasm() must be awaited first!");
2809 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2810 return nativeResponseValue;
2812 // struct LDKOffer CResult_OfferBolt12ParseErrorZ_get_ok(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner);
2814 export function CResult_OfferBolt12ParseErrorZ_get_ok(owner: bigint): bigint {
2815 if(!isWasmInitialized) {
2816 throw new Error("initializeWasm() must be awaited first!");
2818 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_get_ok(owner);
2819 return nativeResponseValue;
2821 // struct LDKBolt12ParseError CResult_OfferBolt12ParseErrorZ_get_err(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner);
2823 export function CResult_OfferBolt12ParseErrorZ_get_err(owner: bigint): bigint {
2824 if(!isWasmInitialized) {
2825 throw new Error("initializeWasm() must be awaited first!");
2827 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_get_err(owner);
2828 return nativeResponseValue;
2830 // struct LDKPublicKey CResult_PublicKeySecp256k1ErrorZ_get_ok(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR owner);
2832 export function CResult_PublicKeySecp256k1ErrorZ_get_ok(owner: bigint): number {
2833 if(!isWasmInitialized) {
2834 throw new Error("initializeWasm() must be awaited first!");
2836 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_get_ok(owner);
2837 return nativeResponseValue;
2839 // enum LDKSecp256k1Error CResult_PublicKeySecp256k1ErrorZ_get_err(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR owner);
2841 export function CResult_PublicKeySecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
2842 if(!isWasmInitialized) {
2843 throw new Error("initializeWasm() must be awaited first!");
2845 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_get_err(owner);
2846 return nativeResponseValue;
2848 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2850 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: bigint): bigint {
2851 if(!isWasmInitialized) {
2852 throw new Error("initializeWasm() must be awaited first!");
2854 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2855 return nativeResponseValue;
2857 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2859 export function CResult_NodeIdDecodeErrorZ_get_err(owner: bigint): bigint {
2860 if(!isWasmInitialized) {
2861 throw new Error("initializeWasm() must be awaited first!");
2863 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2864 return nativeResponseValue;
2867 export class LDKNetworkUpdate {
2868 protected constructor() {}
2871 export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
2872 if(!isWasmInitialized) {
2873 throw new Error("initializeWasm() must be awaited first!");
2875 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
2876 return nativeResponseValue;
2879 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
2880 if(!isWasmInitialized) {
2881 throw new Error("initializeWasm() must be awaited first!");
2883 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
2884 return nativeResponseValue;
2887 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
2888 if(!isWasmInitialized) {
2889 throw new Error("initializeWasm() must be awaited first!");
2891 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
2892 return nativeResponseValue;
2895 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
2896 if(!isWasmInitialized) {
2897 throw new Error("initializeWasm() must be awaited first!");
2899 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
2900 return nativeResponseValue;
2903 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
2904 if(!isWasmInitialized) {
2905 throw new Error("initializeWasm() must be awaited first!");
2907 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
2908 return nativeResponseValue;
2911 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
2912 if(!isWasmInitialized) {
2913 throw new Error("initializeWasm() must be awaited first!");
2915 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
2916 return nativeResponseValue;
2919 export class LDKCOption_NetworkUpdateZ {
2920 protected constructor() {}
2923 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
2924 if(!isWasmInitialized) {
2925 throw new Error("initializeWasm() must be awaited first!");
2927 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
2928 return nativeResponseValue;
2931 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
2932 if(!isWasmInitialized) {
2933 throw new Error("initializeWasm() must be awaited first!");
2935 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
2936 return nativeResponseValue;
2938 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2940 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: bigint): bigint {
2941 if(!isWasmInitialized) {
2942 throw new Error("initializeWasm() must be awaited first!");
2944 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2945 return nativeResponseValue;
2947 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2949 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: bigint): bigint {
2950 if(!isWasmInitialized) {
2951 throw new Error("initializeWasm() must be awaited first!");
2953 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2954 return nativeResponseValue;
2956 // struct LDKTxOut CResult_TxOutUtxoLookupErrorZ_get_ok(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
2958 export function CResult_TxOutUtxoLookupErrorZ_get_ok(owner: bigint): bigint {
2959 if(!isWasmInitialized) {
2960 throw new Error("initializeWasm() must be awaited first!");
2962 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_ok(owner);
2963 return nativeResponseValue;
2965 // enum LDKUtxoLookupError CResult_TxOutUtxoLookupErrorZ_get_err(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
2967 export function CResult_TxOutUtxoLookupErrorZ_get_err(owner: bigint): UtxoLookupError {
2968 if(!isWasmInitialized) {
2969 throw new Error("initializeWasm() must be awaited first!");
2971 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_err(owner);
2972 return nativeResponseValue;
2975 export class LDKUtxoResult {
2976 protected constructor() {}
2979 export function LDKUtxoResult_ty_from_ptr(ptr: bigint): number {
2980 if(!isWasmInitialized) {
2981 throw new Error("initializeWasm() must be awaited first!");
2983 const nativeResponseValue = wasm.TS_LDKUtxoResult_ty_from_ptr(ptr);
2984 return nativeResponseValue;
2987 export function LDKUtxoResult_Sync_get_sync(ptr: bigint): bigint {
2988 if(!isWasmInitialized) {
2989 throw new Error("initializeWasm() must be awaited first!");
2991 const nativeResponseValue = wasm.TS_LDKUtxoResult_Sync_get_sync(ptr);
2992 return nativeResponseValue;
2995 export function LDKUtxoResult_Async_get_async(ptr: bigint): bigint {
2996 if(!isWasmInitialized) {
2997 throw new Error("initializeWasm() must be awaited first!");
2999 const nativeResponseValue = wasm.TS_LDKUtxoResult_Async_get_async(ptr);
3000 return nativeResponseValue;
3003 export interface LDKUtxoLookup {
3004 get_utxo (chain_hash: number, short_channel_id: bigint): bigint;
3008 export function LDKUtxoLookup_new(impl: LDKUtxoLookup): [bigint, number] {
3009 if(!isWasmInitialized) {
3010 throw new Error("initializeWasm() must be awaited first!");
3012 var new_obj_idx = js_objs.length;
3013 for (var i = 0; i < js_objs.length; i++) {
3014 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3016 js_objs[i] = new WeakRef(impl);
3017 return [wasm.TS_LDKUtxoLookup_new(i), i];
3019 // LDKUtxoResult UtxoLookup_get_utxo LDKUtxoLookup *NONNULL_PTR this_arg, const uint8_t (*chain_hash)[32], uint64_t short_channel_id
3021 export function UtxoLookup_get_utxo(this_arg: bigint, chain_hash: number, short_channel_id: bigint): bigint {
3022 if(!isWasmInitialized) {
3023 throw new Error("initializeWasm() must be awaited first!");
3025 const nativeResponseValue = wasm.TS_UtxoLookup_get_utxo(this_arg, chain_hash, short_channel_id);
3026 return nativeResponseValue;
3029 export class LDKCOption_UtxoLookupZ {
3030 protected constructor() {}
3033 export function LDKCOption_UtxoLookupZ_ty_from_ptr(ptr: bigint): number {
3034 if(!isWasmInitialized) {
3035 throw new Error("initializeWasm() must be awaited first!");
3037 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_ty_from_ptr(ptr);
3038 return nativeResponseValue;
3041 export function LDKCOption_UtxoLookupZ_Some_get_some(ptr: bigint): bigint {
3042 if(!isWasmInitialized) {
3043 throw new Error("initializeWasm() must be awaited first!");
3045 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_Some_get_some(ptr);
3046 return nativeResponseValue;
3048 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
3050 export function CResult_NoneLightningErrorZ_get_ok(owner: bigint): void {
3051 if(!isWasmInitialized) {
3052 throw new Error("initializeWasm() must be awaited first!");
3054 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
3055 // debug statements here
3057 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
3059 export function CResult_NoneLightningErrorZ_get_err(owner: bigint): bigint {
3060 if(!isWasmInitialized) {
3061 throw new Error("initializeWasm() must be awaited first!");
3063 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
3064 return nativeResponseValue;
3066 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
3068 export function CResult_boolLightningErrorZ_get_ok(owner: bigint): boolean {
3069 if(!isWasmInitialized) {
3070 throw new Error("initializeWasm() must be awaited first!");
3072 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
3073 return nativeResponseValue;
3075 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
3077 export function CResult_boolLightningErrorZ_get_err(owner: bigint): bigint {
3078 if(!isWasmInitialized) {
3079 throw new Error("initializeWasm() must be awaited first!");
3081 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
3082 return nativeResponseValue;
3084 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3086 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: bigint): bigint {
3087 if(!isWasmInitialized) {
3088 throw new Error("initializeWasm() must be awaited first!");
3090 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
3091 return nativeResponseValue;
3093 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3095 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: bigint): bigint {
3096 if(!isWasmInitialized) {
3097 throw new Error("initializeWasm() must be awaited first!");
3099 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
3100 return nativeResponseValue;
3102 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3104 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: bigint): bigint {
3105 if(!isWasmInitialized) {
3106 throw new Error("initializeWasm() must be awaited first!");
3108 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
3109 return nativeResponseValue;
3112 export class LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
3113 protected constructor() {}
3116 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr: bigint): number {
3117 if(!isWasmInitialized) {
3118 throw new Error("initializeWasm() must be awaited first!");
3120 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr);
3121 return nativeResponseValue;
3124 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr: bigint): bigint {
3125 if(!isWasmInitialized) {
3126 throw new Error("initializeWasm() must be awaited first!");
3128 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr);
3129 return nativeResponseValue;
3132 export class LDKErrorAction {
3133 protected constructor() {}
3136 export function LDKErrorAction_ty_from_ptr(ptr: bigint): number {
3137 if(!isWasmInitialized) {
3138 throw new Error("initializeWasm() must be awaited first!");
3140 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
3141 return nativeResponseValue;
3144 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: bigint): bigint {
3145 if(!isWasmInitialized) {
3146 throw new Error("initializeWasm() must be awaited first!");
3148 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
3149 return nativeResponseValue;
3152 export function LDKErrorAction_DisconnectPeerWithWarning_get_msg(ptr: bigint): bigint {
3153 if(!isWasmInitialized) {
3154 throw new Error("initializeWasm() must be awaited first!");
3156 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeerWithWarning_get_msg(ptr);
3157 return nativeResponseValue;
3160 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: bigint): Level {
3161 if(!isWasmInitialized) {
3162 throw new Error("initializeWasm() must be awaited first!");
3164 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
3165 return nativeResponseValue;
3168 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: bigint): bigint {
3169 if(!isWasmInitialized) {
3170 throw new Error("initializeWasm() must be awaited first!");
3172 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
3173 return nativeResponseValue;
3176 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: bigint): bigint {
3177 if(!isWasmInitialized) {
3178 throw new Error("initializeWasm() must be awaited first!");
3180 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
3181 return nativeResponseValue;
3184 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: bigint): Level {
3185 if(!isWasmInitialized) {
3186 throw new Error("initializeWasm() must be awaited first!");
3188 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
3189 return nativeResponseValue;
3192 export class LDKMessageSendEvent {
3193 protected constructor() {}
3196 export function LDKMessageSendEvent_ty_from_ptr(ptr: bigint): number {
3197 if(!isWasmInitialized) {
3198 throw new Error("initializeWasm() must be awaited first!");
3200 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
3201 return nativeResponseValue;
3204 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: bigint): number {
3205 if(!isWasmInitialized) {
3206 throw new Error("initializeWasm() must be awaited first!");
3208 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
3209 return nativeResponseValue;
3212 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: bigint): bigint {
3213 if(!isWasmInitialized) {
3214 throw new Error("initializeWasm() must be awaited first!");
3216 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
3217 return nativeResponseValue;
3220 export function LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(ptr: bigint): number {
3221 if(!isWasmInitialized) {
3222 throw new Error("initializeWasm() must be awaited first!");
3224 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(ptr);
3225 return nativeResponseValue;
3228 export function LDKMessageSendEvent_SendAcceptChannelV2_get_msg(ptr: bigint): bigint {
3229 if(!isWasmInitialized) {
3230 throw new Error("initializeWasm() must be awaited first!");
3232 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannelV2_get_msg(ptr);
3233 return nativeResponseValue;
3236 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: bigint): number {
3237 if(!isWasmInitialized) {
3238 throw new Error("initializeWasm() must be awaited first!");
3240 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
3241 return nativeResponseValue;
3244 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: bigint): bigint {
3245 if(!isWasmInitialized) {
3246 throw new Error("initializeWasm() must be awaited first!");
3248 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
3249 return nativeResponseValue;
3252 export function LDKMessageSendEvent_SendOpenChannelV2_get_node_id(ptr: bigint): number {
3253 if(!isWasmInitialized) {
3254 throw new Error("initializeWasm() must be awaited first!");
3256 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannelV2_get_node_id(ptr);
3257 return nativeResponseValue;
3260 export function LDKMessageSendEvent_SendOpenChannelV2_get_msg(ptr: bigint): bigint {
3261 if(!isWasmInitialized) {
3262 throw new Error("initializeWasm() must be awaited first!");
3264 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannelV2_get_msg(ptr);
3265 return nativeResponseValue;
3268 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: bigint): number {
3269 if(!isWasmInitialized) {
3270 throw new Error("initializeWasm() must be awaited first!");
3272 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
3273 return nativeResponseValue;
3276 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: bigint): bigint {
3277 if(!isWasmInitialized) {
3278 throw new Error("initializeWasm() must be awaited first!");
3280 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
3281 return nativeResponseValue;
3284 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: bigint): number {
3285 if(!isWasmInitialized) {
3286 throw new Error("initializeWasm() must be awaited first!");
3288 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
3289 return nativeResponseValue;
3292 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: bigint): bigint {
3293 if(!isWasmInitialized) {
3294 throw new Error("initializeWasm() must be awaited first!");
3296 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
3297 return nativeResponseValue;
3300 export function LDKMessageSendEvent_SendTxAddInput_get_node_id(ptr: bigint): number {
3301 if(!isWasmInitialized) {
3302 throw new Error("initializeWasm() must be awaited first!");
3304 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddInput_get_node_id(ptr);
3305 return nativeResponseValue;
3308 export function LDKMessageSendEvent_SendTxAddInput_get_msg(ptr: bigint): bigint {
3309 if(!isWasmInitialized) {
3310 throw new Error("initializeWasm() must be awaited first!");
3312 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddInput_get_msg(ptr);
3313 return nativeResponseValue;
3316 export function LDKMessageSendEvent_SendTxAddOutput_get_node_id(ptr: bigint): number {
3317 if(!isWasmInitialized) {
3318 throw new Error("initializeWasm() must be awaited first!");
3320 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddOutput_get_node_id(ptr);
3321 return nativeResponseValue;
3324 export function LDKMessageSendEvent_SendTxAddOutput_get_msg(ptr: bigint): bigint {
3325 if(!isWasmInitialized) {
3326 throw new Error("initializeWasm() must be awaited first!");
3328 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddOutput_get_msg(ptr);
3329 return nativeResponseValue;
3332 export function LDKMessageSendEvent_SendTxRemoveInput_get_node_id(ptr: bigint): number {
3333 if(!isWasmInitialized) {
3334 throw new Error("initializeWasm() must be awaited first!");
3336 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveInput_get_node_id(ptr);
3337 return nativeResponseValue;
3340 export function LDKMessageSendEvent_SendTxRemoveInput_get_msg(ptr: bigint): bigint {
3341 if(!isWasmInitialized) {
3342 throw new Error("initializeWasm() must be awaited first!");
3344 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveInput_get_msg(ptr);
3345 return nativeResponseValue;
3348 export function LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(ptr: bigint): number {
3349 if(!isWasmInitialized) {
3350 throw new Error("initializeWasm() must be awaited first!");
3352 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(ptr);
3353 return nativeResponseValue;
3356 export function LDKMessageSendEvent_SendTxRemoveOutput_get_msg(ptr: bigint): bigint {
3357 if(!isWasmInitialized) {
3358 throw new Error("initializeWasm() must be awaited first!");
3360 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveOutput_get_msg(ptr);
3361 return nativeResponseValue;
3364 export function LDKMessageSendEvent_SendTxComplete_get_node_id(ptr: bigint): number {
3365 if(!isWasmInitialized) {
3366 throw new Error("initializeWasm() must be awaited first!");
3368 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxComplete_get_node_id(ptr);
3369 return nativeResponseValue;
3372 export function LDKMessageSendEvent_SendTxComplete_get_msg(ptr: bigint): bigint {
3373 if(!isWasmInitialized) {
3374 throw new Error("initializeWasm() must be awaited first!");
3376 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxComplete_get_msg(ptr);
3377 return nativeResponseValue;
3380 export function LDKMessageSendEvent_SendTxSignatures_get_node_id(ptr: bigint): number {
3381 if(!isWasmInitialized) {
3382 throw new Error("initializeWasm() must be awaited first!");
3384 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxSignatures_get_node_id(ptr);
3385 return nativeResponseValue;
3388 export function LDKMessageSendEvent_SendTxSignatures_get_msg(ptr: bigint): bigint {
3389 if(!isWasmInitialized) {
3390 throw new Error("initializeWasm() must be awaited first!");
3392 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxSignatures_get_msg(ptr);
3393 return nativeResponseValue;
3396 export function LDKMessageSendEvent_SendTxInitRbf_get_node_id(ptr: bigint): number {
3397 if(!isWasmInitialized) {
3398 throw new Error("initializeWasm() must be awaited first!");
3400 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxInitRbf_get_node_id(ptr);
3401 return nativeResponseValue;
3404 export function LDKMessageSendEvent_SendTxInitRbf_get_msg(ptr: bigint): bigint {
3405 if(!isWasmInitialized) {
3406 throw new Error("initializeWasm() must be awaited first!");
3408 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxInitRbf_get_msg(ptr);
3409 return nativeResponseValue;
3412 export function LDKMessageSendEvent_SendTxAckRbf_get_node_id(ptr: bigint): number {
3413 if(!isWasmInitialized) {
3414 throw new Error("initializeWasm() must be awaited first!");
3416 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAckRbf_get_node_id(ptr);
3417 return nativeResponseValue;
3420 export function LDKMessageSendEvent_SendTxAckRbf_get_msg(ptr: bigint): bigint {
3421 if(!isWasmInitialized) {
3422 throw new Error("initializeWasm() must be awaited first!");
3424 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAckRbf_get_msg(ptr);
3425 return nativeResponseValue;
3428 export function LDKMessageSendEvent_SendTxAbort_get_node_id(ptr: bigint): number {
3429 if(!isWasmInitialized) {
3430 throw new Error("initializeWasm() must be awaited first!");
3432 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAbort_get_node_id(ptr);
3433 return nativeResponseValue;
3436 export function LDKMessageSendEvent_SendTxAbort_get_msg(ptr: bigint): bigint {
3437 if(!isWasmInitialized) {
3438 throw new Error("initializeWasm() must be awaited first!");
3440 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAbort_get_msg(ptr);
3441 return nativeResponseValue;
3444 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: bigint): number {
3445 if(!isWasmInitialized) {
3446 throw new Error("initializeWasm() must be awaited first!");
3448 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
3449 return nativeResponseValue;
3452 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: bigint): bigint {
3453 if(!isWasmInitialized) {
3454 throw new Error("initializeWasm() must be awaited first!");
3456 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
3457 return nativeResponseValue;
3460 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: bigint): number {
3461 if(!isWasmInitialized) {
3462 throw new Error("initializeWasm() must be awaited first!");
3464 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
3465 return nativeResponseValue;
3468 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: bigint): bigint {
3469 if(!isWasmInitialized) {
3470 throw new Error("initializeWasm() must be awaited first!");
3472 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
3473 return nativeResponseValue;
3476 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: bigint): number {
3477 if(!isWasmInitialized) {
3478 throw new Error("initializeWasm() must be awaited first!");
3480 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
3481 return nativeResponseValue;
3484 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: bigint): bigint {
3485 if(!isWasmInitialized) {
3486 throw new Error("initializeWasm() must be awaited first!");
3488 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
3489 return nativeResponseValue;
3492 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: bigint): number {
3493 if(!isWasmInitialized) {
3494 throw new Error("initializeWasm() must be awaited first!");
3496 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
3497 return nativeResponseValue;
3500 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: bigint): bigint {
3501 if(!isWasmInitialized) {
3502 throw new Error("initializeWasm() must be awaited first!");
3504 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
3505 return nativeResponseValue;
3508 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: bigint): number {
3509 if(!isWasmInitialized) {
3510 throw new Error("initializeWasm() must be awaited first!");
3512 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
3513 return nativeResponseValue;
3516 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: bigint): bigint {
3517 if(!isWasmInitialized) {
3518 throw new Error("initializeWasm() must be awaited first!");
3520 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
3521 return nativeResponseValue;
3524 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: bigint): number {
3525 if(!isWasmInitialized) {
3526 throw new Error("initializeWasm() must be awaited first!");
3528 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
3529 return nativeResponseValue;
3532 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: bigint): bigint {
3533 if(!isWasmInitialized) {
3534 throw new Error("initializeWasm() must be awaited first!");
3536 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
3537 return nativeResponseValue;
3540 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: bigint): number {
3541 if(!isWasmInitialized) {
3542 throw new Error("initializeWasm() must be awaited first!");
3544 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
3545 return nativeResponseValue;
3548 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: bigint): bigint {
3549 if(!isWasmInitialized) {
3550 throw new Error("initializeWasm() must be awaited first!");
3552 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
3553 return nativeResponseValue;
3556 export function LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr: bigint): number {
3557 if(!isWasmInitialized) {
3558 throw new Error("initializeWasm() must be awaited first!");
3560 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr);
3561 return nativeResponseValue;
3564 export function LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr: bigint): bigint {
3565 if(!isWasmInitialized) {
3566 throw new Error("initializeWasm() must be awaited first!");
3568 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr);
3569 return nativeResponseValue;
3572 export function LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
3573 if(!isWasmInitialized) {
3574 throw new Error("initializeWasm() must be awaited first!");
3576 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr);
3577 return nativeResponseValue;
3580 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: bigint): bigint {
3581 if(!isWasmInitialized) {
3582 throw new Error("initializeWasm() must be awaited first!");
3584 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
3585 return nativeResponseValue;
3588 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
3589 if(!isWasmInitialized) {
3590 throw new Error("initializeWasm() must be awaited first!");
3592 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
3593 return nativeResponseValue;
3596 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: bigint): bigint {
3597 if(!isWasmInitialized) {
3598 throw new Error("initializeWasm() must be awaited first!");
3600 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
3601 return nativeResponseValue;
3604 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: bigint): bigint {
3605 if(!isWasmInitialized) {
3606 throw new Error("initializeWasm() must be awaited first!");
3608 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
3609 return nativeResponseValue;
3612 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: bigint): number {
3613 if(!isWasmInitialized) {
3614 throw new Error("initializeWasm() must be awaited first!");
3616 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
3617 return nativeResponseValue;
3620 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: bigint): bigint {
3621 if(!isWasmInitialized) {
3622 throw new Error("initializeWasm() must be awaited first!");
3624 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
3625 return nativeResponseValue;
3628 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: bigint): number {
3629 if(!isWasmInitialized) {
3630 throw new Error("initializeWasm() must be awaited first!");
3632 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
3633 return nativeResponseValue;
3636 export function LDKMessageSendEvent_HandleError_get_action(ptr: bigint): bigint {
3637 if(!isWasmInitialized) {
3638 throw new Error("initializeWasm() must be awaited first!");
3640 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
3641 return nativeResponseValue;
3644 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: bigint): number {
3645 if(!isWasmInitialized) {
3646 throw new Error("initializeWasm() must be awaited first!");
3648 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
3649 return nativeResponseValue;
3652 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: bigint): bigint {
3653 if(!isWasmInitialized) {
3654 throw new Error("initializeWasm() must be awaited first!");
3656 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
3657 return nativeResponseValue;
3660 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: bigint): number {
3661 if(!isWasmInitialized) {
3662 throw new Error("initializeWasm() must be awaited first!");
3664 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
3665 return nativeResponseValue;
3668 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: bigint): bigint {
3669 if(!isWasmInitialized) {
3670 throw new Error("initializeWasm() must be awaited first!");
3672 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
3673 return nativeResponseValue;
3676 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: bigint): number {
3677 if(!isWasmInitialized) {
3678 throw new Error("initializeWasm() must be awaited first!");
3680 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
3681 return nativeResponseValue;
3684 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: bigint): bigint {
3685 if(!isWasmInitialized) {
3686 throw new Error("initializeWasm() must be awaited first!");
3688 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
3689 return nativeResponseValue;
3692 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: bigint): number {
3693 if(!isWasmInitialized) {
3694 throw new Error("initializeWasm() must be awaited first!");
3696 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
3697 return nativeResponseValue;
3700 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: bigint): bigint {
3701 if(!isWasmInitialized) {
3702 throw new Error("initializeWasm() must be awaited first!");
3704 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
3705 return nativeResponseValue;
3707 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
3709 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3710 if(!isWasmInitialized) {
3711 throw new Error("initializeWasm() must be awaited first!");
3713 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
3714 return nativeResponseValue;
3716 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
3718 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3719 if(!isWasmInitialized) {
3720 throw new Error("initializeWasm() must be awaited first!");
3722 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
3723 return nativeResponseValue;
3725 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
3727 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3728 if(!isWasmInitialized) {
3729 throw new Error("initializeWasm() must be awaited first!");
3731 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
3732 return nativeResponseValue;
3734 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
3736 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3737 if(!isWasmInitialized) {
3738 throw new Error("initializeWasm() must be awaited first!");
3740 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
3741 return nativeResponseValue;
3743 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
3745 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: bigint): bigint {
3746 if(!isWasmInitialized) {
3747 throw new Error("initializeWasm() must be awaited first!");
3749 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
3750 return nativeResponseValue;
3752 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
3754 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: bigint): bigint {
3755 if(!isWasmInitialized) {
3756 throw new Error("initializeWasm() must be awaited first!");
3758 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
3759 return nativeResponseValue;
3762 export class LDKSocketAddress {
3763 protected constructor() {}
3766 export function LDKSocketAddress_ty_from_ptr(ptr: bigint): number {
3767 if(!isWasmInitialized) {
3768 throw new Error("initializeWasm() must be awaited first!");
3770 const nativeResponseValue = wasm.TS_LDKSocketAddress_ty_from_ptr(ptr);
3771 return nativeResponseValue;
3774 export function LDKSocketAddress_TcpIpV4_get_addr(ptr: bigint): number {
3775 if(!isWasmInitialized) {
3776 throw new Error("initializeWasm() must be awaited first!");
3778 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV4_get_addr(ptr);
3779 return nativeResponseValue;
3782 export function LDKSocketAddress_TcpIpV4_get_port(ptr: bigint): number {
3783 if(!isWasmInitialized) {
3784 throw new Error("initializeWasm() must be awaited first!");
3786 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV4_get_port(ptr);
3787 return nativeResponseValue;
3790 export function LDKSocketAddress_TcpIpV6_get_addr(ptr: bigint): number {
3791 if(!isWasmInitialized) {
3792 throw new Error("initializeWasm() must be awaited first!");
3794 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV6_get_addr(ptr);
3795 return nativeResponseValue;
3798 export function LDKSocketAddress_TcpIpV6_get_port(ptr: bigint): number {
3799 if(!isWasmInitialized) {
3800 throw new Error("initializeWasm() must be awaited first!");
3802 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV6_get_port(ptr);
3803 return nativeResponseValue;
3806 export function LDKSocketAddress_OnionV2_get_onion_v2(ptr: bigint): number {
3807 if(!isWasmInitialized) {
3808 throw new Error("initializeWasm() must be awaited first!");
3810 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV2_get_onion_v2(ptr);
3811 return nativeResponseValue;
3814 export function LDKSocketAddress_OnionV3_get_ed25519_pubkey(ptr: bigint): number {
3815 if(!isWasmInitialized) {
3816 throw new Error("initializeWasm() must be awaited first!");
3818 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_ed25519_pubkey(ptr);
3819 return nativeResponseValue;
3822 export function LDKSocketAddress_OnionV3_get_checksum(ptr: bigint): number {
3823 if(!isWasmInitialized) {
3824 throw new Error("initializeWasm() must be awaited first!");
3826 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_checksum(ptr);
3827 return nativeResponseValue;
3830 export function LDKSocketAddress_OnionV3_get_version(ptr: bigint): number {
3831 if(!isWasmInitialized) {
3832 throw new Error("initializeWasm() must be awaited first!");
3834 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_version(ptr);
3835 return nativeResponseValue;
3838 export function LDKSocketAddress_OnionV3_get_port(ptr: bigint): number {
3839 if(!isWasmInitialized) {
3840 throw new Error("initializeWasm() must be awaited first!");
3842 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_port(ptr);
3843 return nativeResponseValue;
3846 export function LDKSocketAddress_Hostname_get_hostname(ptr: bigint): bigint {
3847 if(!isWasmInitialized) {
3848 throw new Error("initializeWasm() must be awaited first!");
3850 const nativeResponseValue = wasm.TS_LDKSocketAddress_Hostname_get_hostname(ptr);
3851 return nativeResponseValue;
3854 export function LDKSocketAddress_Hostname_get_port(ptr: bigint): number {
3855 if(!isWasmInitialized) {
3856 throw new Error("initializeWasm() must be awaited first!");
3858 const nativeResponseValue = wasm.TS_LDKSocketAddress_Hostname_get_port(ptr);
3859 return nativeResponseValue;
3861 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3863 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3864 if(!isWasmInitialized) {
3865 throw new Error("initializeWasm() must be awaited first!");
3867 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
3868 return nativeResponseValue;
3870 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3872 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3873 if(!isWasmInitialized) {
3874 throw new Error("initializeWasm() must be awaited first!");
3876 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
3877 return nativeResponseValue;
3879 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3881 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: bigint): bigint {
3882 if(!isWasmInitialized) {
3883 throw new Error("initializeWasm() must be awaited first!");
3885 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
3886 return nativeResponseValue;
3888 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3890 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: bigint): bigint {
3891 if(!isWasmInitialized) {
3892 throw new Error("initializeWasm() must be awaited first!");
3894 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
3895 return nativeResponseValue;
3897 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3899 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3900 if(!isWasmInitialized) {
3901 throw new Error("initializeWasm() must be awaited first!");
3903 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
3904 return nativeResponseValue;
3906 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3908 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3909 if(!isWasmInitialized) {
3910 throw new Error("initializeWasm() must be awaited first!");
3912 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
3913 return nativeResponseValue;
3915 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3917 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: bigint): bigint {
3918 if(!isWasmInitialized) {
3919 throw new Error("initializeWasm() must be awaited first!");
3921 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
3922 return nativeResponseValue;
3924 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3926 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: bigint): bigint {
3927 if(!isWasmInitialized) {
3928 throw new Error("initializeWasm() must be awaited first!");
3930 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
3931 return nativeResponseValue;
3934 export class LDKCOption_CVec_SocketAddressZZ {
3935 protected constructor() {}
3938 export function LDKCOption_CVec_SocketAddressZZ_ty_from_ptr(ptr: bigint): number {
3939 if(!isWasmInitialized) {
3940 throw new Error("initializeWasm() must be awaited first!");
3942 const nativeResponseValue = wasm.TS_LDKCOption_CVec_SocketAddressZZ_ty_from_ptr(ptr);
3943 return nativeResponseValue;
3946 export function LDKCOption_CVec_SocketAddressZZ_Some_get_some(ptr: bigint): number {
3947 if(!isWasmInitialized) {
3948 throw new Error("initializeWasm() must be awaited first!");
3950 const nativeResponseValue = wasm.TS_LDKCOption_CVec_SocketAddressZZ_Some_get_some(ptr);
3951 return nativeResponseValue;
3954 export class LDKCOption_TxOutZ {
3955 protected constructor() {}
3958 export function LDKCOption_TxOutZ_ty_from_ptr(ptr: bigint): number {
3959 if(!isWasmInitialized) {
3960 throw new Error("initializeWasm() must be awaited first!");
3962 const nativeResponseValue = wasm.TS_LDKCOption_TxOutZ_ty_from_ptr(ptr);
3963 return nativeResponseValue;
3966 export function LDKCOption_TxOutZ_Some_get_some(ptr: bigint): bigint {
3967 if(!isWasmInitialized) {
3968 throw new Error("initializeWasm() must be awaited first!");
3970 const nativeResponseValue = wasm.TS_LDKCOption_TxOutZ_Some_get_some(ptr);
3971 return nativeResponseValue;
3973 // struct LDKCoinSelection CResult_CoinSelectionNoneZ_get_ok(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner);
3975 export function CResult_CoinSelectionNoneZ_get_ok(owner: bigint): bigint {
3976 if(!isWasmInitialized) {
3977 throw new Error("initializeWasm() must be awaited first!");
3979 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_get_ok(owner);
3980 return nativeResponseValue;
3982 // void CResult_CoinSelectionNoneZ_get_err(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner);
3984 export function CResult_CoinSelectionNoneZ_get_err(owner: bigint): void {
3985 if(!isWasmInitialized) {
3986 throw new Error("initializeWasm() must be awaited first!");
3988 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_get_err(owner);
3989 // debug statements here
3991 // struct LDKCVec_UtxoZ CResult_CVec_UtxoZNoneZ_get_ok(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner);
3993 export function CResult_CVec_UtxoZNoneZ_get_ok(owner: bigint): number {
3994 if(!isWasmInitialized) {
3995 throw new Error("initializeWasm() must be awaited first!");
3997 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_get_ok(owner);
3998 return nativeResponseValue;
4000 // void CResult_CVec_UtxoZNoneZ_get_err(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner);
4002 export function CResult_CVec_UtxoZNoneZ_get_err(owner: bigint): void {
4003 if(!isWasmInitialized) {
4004 throw new Error("initializeWasm() must be awaited first!");
4006 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_get_err(owner);
4007 // debug statements here
4009 // uint64_t C2Tuple_u64u16Z_get_a(LDKC2Tuple_u64u16Z *NONNULL_PTR owner);
4011 export function C2Tuple_u64u16Z_get_a(owner: bigint): bigint {
4012 if(!isWasmInitialized) {
4013 throw new Error("initializeWasm() must be awaited first!");
4015 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_get_a(owner);
4016 return nativeResponseValue;
4018 // uint16_t C2Tuple_u64u16Z_get_b(LDKC2Tuple_u64u16Z *NONNULL_PTR owner);
4020 export function C2Tuple_u64u16Z_get_b(owner: bigint): number {
4021 if(!isWasmInitialized) {
4022 throw new Error("initializeWasm() must be awaited first!");
4024 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_get_b(owner);
4025 return nativeResponseValue;
4028 export class LDKCOption_C2Tuple_u64u16ZZ {
4029 protected constructor() {}
4032 export function LDKCOption_C2Tuple_u64u16ZZ_ty_from_ptr(ptr: bigint): number {
4033 if(!isWasmInitialized) {
4034 throw new Error("initializeWasm() must be awaited first!");
4036 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u16ZZ_ty_from_ptr(ptr);
4037 return nativeResponseValue;
4040 export function LDKCOption_C2Tuple_u64u16ZZ_Some_get_some(ptr: bigint): bigint {
4041 if(!isWasmInitialized) {
4042 throw new Error("initializeWasm() must be awaited first!");
4044 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u16ZZ_Some_get_some(ptr);
4045 return nativeResponseValue;
4048 export class LDKCOption_ChannelShutdownStateZ {
4049 protected constructor() {}
4052 export function LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr: bigint): number {
4053 if(!isWasmInitialized) {
4054 throw new Error("initializeWasm() must be awaited first!");
4056 const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr);
4057 return nativeResponseValue;
4060 export function LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr: bigint): ChannelShutdownState {
4061 if(!isWasmInitialized) {
4062 throw new Error("initializeWasm() must be awaited first!");
4064 const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr);
4065 return nativeResponseValue;
4067 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesAPIErrorZ_get_ok(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR owner);
4069 export function CResult_ThirtyTwoBytesAPIErrorZ_get_ok(owner: bigint): number {
4070 if(!isWasmInitialized) {
4071 throw new Error("initializeWasm() must be awaited first!");
4073 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_get_ok(owner);
4074 return nativeResponseValue;
4076 // struct LDKAPIError CResult_ThirtyTwoBytesAPIErrorZ_get_err(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR owner);
4078 export function CResult_ThirtyTwoBytesAPIErrorZ_get_err(owner: bigint): bigint {
4079 if(!isWasmInitialized) {
4080 throw new Error("initializeWasm() must be awaited first!");
4082 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_get_err(owner);
4083 return nativeResponseValue;
4086 export class LDKRecentPaymentDetails {
4087 protected constructor() {}
4090 export function LDKRecentPaymentDetails_ty_from_ptr(ptr: bigint): number {
4091 if(!isWasmInitialized) {
4092 throw new Error("initializeWasm() must be awaited first!");
4094 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_ty_from_ptr(ptr);
4095 return nativeResponseValue;
4098 export function LDKRecentPaymentDetails_AwaitingInvoice_get_payment_id(ptr: bigint): number {
4099 if(!isWasmInitialized) {
4100 throw new Error("initializeWasm() must be awaited first!");
4102 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_AwaitingInvoice_get_payment_id(ptr);
4103 return nativeResponseValue;
4106 export function LDKRecentPaymentDetails_Pending_get_payment_id(ptr: bigint): number {
4107 if(!isWasmInitialized) {
4108 throw new Error("initializeWasm() must be awaited first!");
4110 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_payment_id(ptr);
4111 return nativeResponseValue;
4114 export function LDKRecentPaymentDetails_Pending_get_payment_hash(ptr: bigint): number {
4115 if(!isWasmInitialized) {
4116 throw new Error("initializeWasm() must be awaited first!");
4118 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_payment_hash(ptr);
4119 return nativeResponseValue;
4122 export function LDKRecentPaymentDetails_Pending_get_total_msat(ptr: bigint): bigint {
4123 if(!isWasmInitialized) {
4124 throw new Error("initializeWasm() must be awaited first!");
4126 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_total_msat(ptr);
4127 return nativeResponseValue;
4130 export function LDKRecentPaymentDetails_Fulfilled_get_payment_id(ptr: bigint): number {
4131 if(!isWasmInitialized) {
4132 throw new Error("initializeWasm() must be awaited first!");
4134 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Fulfilled_get_payment_id(ptr);
4135 return nativeResponseValue;
4138 export function LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr: bigint): bigint {
4139 if(!isWasmInitialized) {
4140 throw new Error("initializeWasm() must be awaited first!");
4142 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr);
4143 return nativeResponseValue;
4146 export function LDKRecentPaymentDetails_Abandoned_get_payment_id(ptr: bigint): number {
4147 if(!isWasmInitialized) {
4148 throw new Error("initializeWasm() must be awaited first!");
4150 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Abandoned_get_payment_id(ptr);
4151 return nativeResponseValue;
4154 export function LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr: bigint): number {
4155 if(!isWasmInitialized) {
4156 throw new Error("initializeWasm() must be awaited first!");
4158 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr);
4159 return nativeResponseValue;
4162 export class LDKPaymentSendFailure {
4163 protected constructor() {}
4166 export function LDKPaymentSendFailure_ty_from_ptr(ptr: bigint): number {
4167 if(!isWasmInitialized) {
4168 throw new Error("initializeWasm() must be awaited first!");
4170 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
4171 return nativeResponseValue;
4174 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: bigint): bigint {
4175 if(!isWasmInitialized) {
4176 throw new Error("initializeWasm() must be awaited first!");
4178 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
4179 return nativeResponseValue;
4182 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: bigint): number {
4183 if(!isWasmInitialized) {
4184 throw new Error("initializeWasm() must be awaited first!");
4186 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
4187 return nativeResponseValue;
4190 export function LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr: bigint): number {
4191 if(!isWasmInitialized) {
4192 throw new Error("initializeWasm() must be awaited first!");
4194 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr);
4195 return nativeResponseValue;
4198 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: bigint): number {
4199 if(!isWasmInitialized) {
4200 throw new Error("initializeWasm() must be awaited first!");
4202 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
4203 return nativeResponseValue;
4206 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: bigint): bigint {
4207 if(!isWasmInitialized) {
4208 throw new Error("initializeWasm() must be awaited first!");
4210 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
4211 return nativeResponseValue;
4214 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: bigint): number {
4215 if(!isWasmInitialized) {
4216 throw new Error("initializeWasm() must be awaited first!");
4218 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
4219 return nativeResponseValue;
4221 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4223 export function CResult_NonePaymentSendFailureZ_get_ok(owner: bigint): void {
4224 if(!isWasmInitialized) {
4225 throw new Error("initializeWasm() must be awaited first!");
4227 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
4228 // debug statements here
4230 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4232 export function CResult_NonePaymentSendFailureZ_get_err(owner: bigint): bigint {
4233 if(!isWasmInitialized) {
4234 throw new Error("initializeWasm() must be awaited first!");
4236 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
4237 return nativeResponseValue;
4239 // void CResult_NoneRetryableSendFailureZ_get_ok(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
4241 export function CResult_NoneRetryableSendFailureZ_get_ok(owner: bigint): void {
4242 if(!isWasmInitialized) {
4243 throw new Error("initializeWasm() must be awaited first!");
4245 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_ok(owner);
4246 // debug statements here
4248 // enum LDKRetryableSendFailure CResult_NoneRetryableSendFailureZ_get_err(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
4250 export function CResult_NoneRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
4251 if(!isWasmInitialized) {
4252 throw new Error("initializeWasm() must be awaited first!");
4254 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_err(owner);
4255 return nativeResponseValue;
4257 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR owner);
4259 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(owner: bigint): number {
4260 if(!isWasmInitialized) {
4261 throw new Error("initializeWasm() must be awaited first!");
4263 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(owner);
4264 return nativeResponseValue;
4266 // struct LDKPaymentSendFailure CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR owner);
4268 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(owner: bigint): bigint {
4269 if(!isWasmInitialized) {
4270 throw new Error("initializeWasm() must be awaited first!");
4272 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(owner);
4273 return nativeResponseValue;
4275 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR owner);
4277 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(owner: bigint): number {
4278 if(!isWasmInitialized) {
4279 throw new Error("initializeWasm() must be awaited first!");
4281 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(owner);
4282 return nativeResponseValue;
4284 // enum LDKRetryableSendFailure CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR owner);
4286 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
4287 if(!isWasmInitialized) {
4288 throw new Error("initializeWasm() must be awaited first!");
4290 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(owner);
4291 return nativeResponseValue;
4293 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR owner);
4295 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(owner: bigint): number {
4296 if(!isWasmInitialized) {
4297 throw new Error("initializeWasm() must be awaited first!");
4299 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(owner);
4300 return nativeResponseValue;
4302 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR owner);
4304 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(owner: bigint): number {
4305 if(!isWasmInitialized) {
4306 throw new Error("initializeWasm() must be awaited first!");
4308 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(owner);
4309 return nativeResponseValue;
4311 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR owner);
4313 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(owner: bigint): bigint {
4314 if(!isWasmInitialized) {
4315 throw new Error("initializeWasm() must be awaited first!");
4317 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(owner);
4318 return nativeResponseValue;
4320 // struct LDKPaymentSendFailure CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR owner);
4322 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(owner: bigint): bigint {
4323 if(!isWasmInitialized) {
4324 throw new Error("initializeWasm() must be awaited first!");
4326 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(owner);
4327 return nativeResponseValue;
4330 export class LDKProbeSendFailure {
4331 protected constructor() {}
4334 export function LDKProbeSendFailure_ty_from_ptr(ptr: bigint): number {
4335 if(!isWasmInitialized) {
4336 throw new Error("initializeWasm() must be awaited first!");
4338 const nativeResponseValue = wasm.TS_LDKProbeSendFailure_ty_from_ptr(ptr);
4339 return nativeResponseValue;
4342 export function LDKProbeSendFailure_SendingFailed_get_sending_failed(ptr: bigint): bigint {
4343 if(!isWasmInitialized) {
4344 throw new Error("initializeWasm() must be awaited first!");
4346 const nativeResponseValue = wasm.TS_LDKProbeSendFailure_SendingFailed_get_sending_failed(ptr);
4347 return nativeResponseValue;
4349 // struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR owner);
4351 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(owner: bigint): number {
4352 if(!isWasmInitialized) {
4353 throw new Error("initializeWasm() must be awaited first!");
4355 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(owner);
4356 return nativeResponseValue;
4358 // struct LDKProbeSendFailure CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR owner);
4360 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(owner: bigint): bigint {
4361 if(!isWasmInitialized) {
4362 throw new Error("initializeWasm() must be awaited first!");
4364 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(owner);
4365 return nativeResponseValue;
4367 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR owner);
4369 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(owner: bigint): number {
4370 if(!isWasmInitialized) {
4371 throw new Error("initializeWasm() must be awaited first!");
4373 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(owner);
4374 return nativeResponseValue;
4376 // struct LDKPublicKey C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR owner);
4378 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(owner: bigint): number {
4379 if(!isWasmInitialized) {
4380 throw new Error("initializeWasm() must be awaited first!");
4382 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(owner);
4383 return nativeResponseValue;
4386 export class LDKCOption_StrZ {
4387 protected constructor() {}
4390 export function LDKCOption_StrZ_ty_from_ptr(ptr: bigint): number {
4391 if(!isWasmInitialized) {
4392 throw new Error("initializeWasm() must be awaited first!");
4394 const nativeResponseValue = wasm.TS_LDKCOption_StrZ_ty_from_ptr(ptr);
4395 return nativeResponseValue;
4398 export function LDKCOption_StrZ_Some_get_some(ptr: bigint): number {
4399 if(!isWasmInitialized) {
4400 throw new Error("initializeWasm() must be awaited first!");
4402 const nativeResponseValue = wasm.TS_LDKCOption_StrZ_Some_get_some(ptr);
4403 return nativeResponseValue;
4405 // void CResult_NoneBolt12SemanticErrorZ_get_ok(LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR owner);
4407 export function CResult_NoneBolt12SemanticErrorZ_get_ok(owner: bigint): void {
4408 if(!isWasmInitialized) {
4409 throw new Error("initializeWasm() must be awaited first!");
4411 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_get_ok(owner);
4412 // debug statements here
4414 // enum LDKBolt12SemanticError CResult_NoneBolt12SemanticErrorZ_get_err(LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR owner);
4416 export function CResult_NoneBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
4417 if(!isWasmInitialized) {
4418 throw new Error("initializeWasm() must be awaited first!");
4420 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_get_err(owner);
4421 return nativeResponseValue;
4423 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR owner);
4425 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(owner: bigint): bigint {
4426 if(!isWasmInitialized) {
4427 throw new Error("initializeWasm() must be awaited first!");
4429 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(owner);
4430 return nativeResponseValue;
4432 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR owner);
4434 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(owner: bigint): void {
4435 if(!isWasmInitialized) {
4436 throw new Error("initializeWasm() must be awaited first!");
4438 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(owner);
4439 // debug statements here
4442 export class LDKOffersMessage {
4443 protected constructor() {}
4446 export function LDKOffersMessage_ty_from_ptr(ptr: bigint): number {
4447 if(!isWasmInitialized) {
4448 throw new Error("initializeWasm() must be awaited first!");
4450 const nativeResponseValue = wasm.TS_LDKOffersMessage_ty_from_ptr(ptr);
4451 return nativeResponseValue;
4454 export function LDKOffersMessage_InvoiceRequest_get_invoice_request(ptr: bigint): bigint {
4455 if(!isWasmInitialized) {
4456 throw new Error("initializeWasm() must be awaited first!");
4458 const nativeResponseValue = wasm.TS_LDKOffersMessage_InvoiceRequest_get_invoice_request(ptr);
4459 return nativeResponseValue;
4462 export function LDKOffersMessage_Invoice_get_invoice(ptr: bigint): bigint {
4463 if(!isWasmInitialized) {
4464 throw new Error("initializeWasm() must be awaited first!");
4466 const nativeResponseValue = wasm.TS_LDKOffersMessage_Invoice_get_invoice(ptr);
4467 return nativeResponseValue;
4470 export function LDKOffersMessage_InvoiceError_get_invoice_error(ptr: bigint): bigint {
4471 if(!isWasmInitialized) {
4472 throw new Error("initializeWasm() must be awaited first!");
4474 const nativeResponseValue = wasm.TS_LDKOffersMessage_InvoiceError_get_invoice_error(ptr);
4475 return nativeResponseValue;
4478 export class LDKCOption_OffersMessageZ {
4479 protected constructor() {}
4482 export function LDKCOption_OffersMessageZ_ty_from_ptr(ptr: bigint): number {
4483 if(!isWasmInitialized) {
4484 throw new Error("initializeWasm() must be awaited first!");
4486 const nativeResponseValue = wasm.TS_LDKCOption_OffersMessageZ_ty_from_ptr(ptr);
4487 return nativeResponseValue;
4490 export function LDKCOption_OffersMessageZ_Some_get_some(ptr: bigint): bigint {
4491 if(!isWasmInitialized) {
4492 throw new Error("initializeWasm() must be awaited first!");
4494 const nativeResponseValue = wasm.TS_LDKCOption_OffersMessageZ_Some_get_some(ptr);
4495 return nativeResponseValue;
4498 export class LDKDestination {
4499 protected constructor() {}
4502 export function LDKDestination_ty_from_ptr(ptr: bigint): number {
4503 if(!isWasmInitialized) {
4504 throw new Error("initializeWasm() must be awaited first!");
4506 const nativeResponseValue = wasm.TS_LDKDestination_ty_from_ptr(ptr);
4507 return nativeResponseValue;
4510 export function LDKDestination_Node_get_node(ptr: bigint): number {
4511 if(!isWasmInitialized) {
4512 throw new Error("initializeWasm() must be awaited first!");
4514 const nativeResponseValue = wasm.TS_LDKDestination_Node_get_node(ptr);
4515 return nativeResponseValue;
4518 export function LDKDestination_BlindedPath_get_blinded_path(ptr: bigint): bigint {
4519 if(!isWasmInitialized) {
4520 throw new Error("initializeWasm() must be awaited first!");
4522 const nativeResponseValue = wasm.TS_LDKDestination_BlindedPath_get_blinded_path(ptr);
4523 return nativeResponseValue;
4525 // struct LDKOffersMessage C3Tuple_OffersMessageDestinationBlindedPathZ_get_a(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR owner);
4527 export function C3Tuple_OffersMessageDestinationBlindedPathZ_get_a(owner: bigint): bigint {
4528 if(!isWasmInitialized) {
4529 throw new Error("initializeWasm() must be awaited first!");
4531 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_get_a(owner);
4532 return nativeResponseValue;
4534 // struct LDKDestination C3Tuple_OffersMessageDestinationBlindedPathZ_get_b(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR owner);
4536 export function C3Tuple_OffersMessageDestinationBlindedPathZ_get_b(owner: bigint): bigint {
4537 if(!isWasmInitialized) {
4538 throw new Error("initializeWasm() must be awaited first!");
4540 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_get_b(owner);
4541 return nativeResponseValue;
4543 // struct LDKBlindedPath C3Tuple_OffersMessageDestinationBlindedPathZ_get_c(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR owner);
4545 export function C3Tuple_OffersMessageDestinationBlindedPathZ_get_c(owner: bigint): bigint {
4546 if(!isWasmInitialized) {
4547 throw new Error("initializeWasm() must be awaited first!");
4549 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_get_c(owner);
4550 return nativeResponseValue;
4552 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4554 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4555 if(!isWasmInitialized) {
4556 throw new Error("initializeWasm() must be awaited first!");
4558 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
4559 return nativeResponseValue;
4561 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4563 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4564 if(!isWasmInitialized) {
4565 throw new Error("initializeWasm() must be awaited first!");
4567 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
4568 return nativeResponseValue;
4570 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4572 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
4573 if(!isWasmInitialized) {
4574 throw new Error("initializeWasm() must be awaited first!");
4576 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
4577 return nativeResponseValue;
4579 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4581 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
4582 if(!isWasmInitialized) {
4583 throw new Error("initializeWasm() must be awaited first!");
4585 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
4586 return nativeResponseValue;
4588 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4590 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
4591 if(!isWasmInitialized) {
4592 throw new Error("initializeWasm() must be awaited first!");
4594 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
4595 return nativeResponseValue;
4597 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4599 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
4600 if(!isWasmInitialized) {
4601 throw new Error("initializeWasm() must be awaited first!");
4603 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
4604 return nativeResponseValue;
4606 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4608 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: bigint): bigint {
4609 if(!isWasmInitialized) {
4610 throw new Error("initializeWasm() must be awaited first!");
4612 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
4613 return nativeResponseValue;
4615 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4617 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: bigint): bigint {
4618 if(!isWasmInitialized) {
4619 throw new Error("initializeWasm() must be awaited first!");
4621 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
4622 return nativeResponseValue;
4624 // enum LDKChannelShutdownState CResult_ChannelShutdownStateDecodeErrorZ_get_ok(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
4626 export function CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner: bigint): ChannelShutdownState {
4627 if(!isWasmInitialized) {
4628 throw new Error("initializeWasm() must be awaited first!");
4630 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner);
4631 return nativeResponseValue;
4633 // struct LDKDecodeError CResult_ChannelShutdownStateDecodeErrorZ_get_err(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
4635 export function CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner: bigint): bigint {
4636 if(!isWasmInitialized) {
4637 throw new Error("initializeWasm() must be awaited first!");
4639 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner);
4640 return nativeResponseValue;
4643 export interface LDKWatch {
4644 watch_channel (funding_txo: bigint, monitor: bigint): bigint;
4645 update_channel (funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus;
4646 release_pending_monitor_events (): number;
4650 export function LDKWatch_new(impl: LDKWatch): [bigint, number] {
4651 if(!isWasmInitialized) {
4652 throw new Error("initializeWasm() must be awaited first!");
4654 var new_obj_idx = js_objs.length;
4655 for (var i = 0; i < js_objs.length; i++) {
4656 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4658 js_objs[i] = new WeakRef(impl);
4659 return [wasm.TS_LDKWatch_new(i), i];
4661 // LDKCResult_ChannelMonitorUpdateStatusNoneZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
4663 export function Watch_watch_channel(this_arg: bigint, funding_txo: bigint, monitor: bigint): bigint {
4664 if(!isWasmInitialized) {
4665 throw new Error("initializeWasm() must be awaited first!");
4667 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
4668 return nativeResponseValue;
4670 // LDKChannelMonitorUpdateStatus Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update
4672 export function Watch_update_channel(this_arg: bigint, funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus {
4673 if(!isWasmInitialized) {
4674 throw new Error("initializeWasm() must be awaited first!");
4676 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
4677 return nativeResponseValue;
4679 // LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
4681 export function Watch_release_pending_monitor_events(this_arg: bigint): number {
4682 if(!isWasmInitialized) {
4683 throw new Error("initializeWasm() must be awaited first!");
4685 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
4686 return nativeResponseValue;
4689 export interface LDKBroadcasterInterface {
4690 broadcast_transactions (txs: number): void;
4694 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): [bigint, number] {
4695 if(!isWasmInitialized) {
4696 throw new Error("initializeWasm() must be awaited first!");
4698 var new_obj_idx = js_objs.length;
4699 for (var i = 0; i < js_objs.length; i++) {
4700 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4702 js_objs[i] = new WeakRef(impl);
4703 return [wasm.TS_LDKBroadcasterInterface_new(i), i];
4705 // void BroadcasterInterface_broadcast_transactions LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKCVec_TransactionZ txs
4707 export function BroadcasterInterface_broadcast_transactions(this_arg: bigint, txs: number): void {
4708 if(!isWasmInitialized) {
4709 throw new Error("initializeWasm() must be awaited first!");
4711 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transactions(this_arg, txs);
4712 // debug statements here
4715 export interface LDKEntropySource {
4716 get_secure_random_bytes (): number;
4720 export function LDKEntropySource_new(impl: LDKEntropySource): [bigint, number] {
4721 if(!isWasmInitialized) {
4722 throw new Error("initializeWasm() must be awaited first!");
4724 var new_obj_idx = js_objs.length;
4725 for (var i = 0; i < js_objs.length; i++) {
4726 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4728 js_objs[i] = new WeakRef(impl);
4729 return [wasm.TS_LDKEntropySource_new(i), i];
4731 // LDKThirtyTwoBytes EntropySource_get_secure_random_bytes LDKEntropySource *NONNULL_PTR this_arg
4733 export function EntropySource_get_secure_random_bytes(this_arg: bigint): number {
4734 if(!isWasmInitialized) {
4735 throw new Error("initializeWasm() must be awaited first!");
4737 const nativeResponseValue = wasm.TS_EntropySource_get_secure_random_bytes(this_arg);
4738 return nativeResponseValue;
4741 export class LDKUnsignedGossipMessage {
4742 protected constructor() {}
4745 export function LDKUnsignedGossipMessage_ty_from_ptr(ptr: bigint): number {
4746 if(!isWasmInitialized) {
4747 throw new Error("initializeWasm() must be awaited first!");
4749 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ty_from_ptr(ptr);
4750 return nativeResponseValue;
4753 export function LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr: bigint): bigint {
4754 if(!isWasmInitialized) {
4755 throw new Error("initializeWasm() must be awaited first!");
4757 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr);
4758 return nativeResponseValue;
4761 export function LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr: bigint): bigint {
4762 if(!isWasmInitialized) {
4763 throw new Error("initializeWasm() must be awaited first!");
4765 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr);
4766 return nativeResponseValue;
4769 export function LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr: bigint): bigint {
4770 if(!isWasmInitialized) {
4771 throw new Error("initializeWasm() must be awaited first!");
4773 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr);
4774 return nativeResponseValue;
4777 export interface LDKNodeSigner {
4778 get_inbound_payment_key_material (): number;
4779 get_node_id (recipient: Recipient): bigint;
4780 ecdh (recipient: Recipient, other_key: number, tweak: bigint): bigint;
4781 sign_invoice (hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint;
4782 sign_bolt12_invoice_request (invoice_request: bigint): bigint;
4783 sign_bolt12_invoice (invoice: bigint): bigint;
4784 sign_gossip_message (msg: bigint): bigint;
4788 export function LDKNodeSigner_new(impl: LDKNodeSigner): [bigint, number] {
4789 if(!isWasmInitialized) {
4790 throw new Error("initializeWasm() must be awaited first!");
4792 var new_obj_idx = js_objs.length;
4793 for (var i = 0; i < js_objs.length; i++) {
4794 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4796 js_objs[i] = new WeakRef(impl);
4797 return [wasm.TS_LDKNodeSigner_new(i), i];
4799 // LDKThirtyTwoBytes NodeSigner_get_inbound_payment_key_material LDKNodeSigner *NONNULL_PTR this_arg
4801 export function NodeSigner_get_inbound_payment_key_material(this_arg: bigint): number {
4802 if(!isWasmInitialized) {
4803 throw new Error("initializeWasm() must be awaited first!");
4805 const nativeResponseValue = wasm.TS_NodeSigner_get_inbound_payment_key_material(this_arg);
4806 return nativeResponseValue;
4808 // LDKCResult_PublicKeyNoneZ NodeSigner_get_node_id LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient
4810 export function NodeSigner_get_node_id(this_arg: bigint, recipient: Recipient): bigint {
4811 if(!isWasmInitialized) {
4812 throw new Error("initializeWasm() must be awaited first!");
4814 const nativeResponseValue = wasm.TS_NodeSigner_get_node_id(this_arg, recipient);
4815 return nativeResponseValue;
4817 // LDKCResult_ThirtyTwoBytesNoneZ NodeSigner_ecdh LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak
4819 export function NodeSigner_ecdh(this_arg: bigint, recipient: Recipient, other_key: number, tweak: bigint): bigint {
4820 if(!isWasmInitialized) {
4821 throw new Error("initializeWasm() must be awaited first!");
4823 const nativeResponseValue = wasm.TS_NodeSigner_ecdh(this_arg, recipient, other_key, tweak);
4824 return nativeResponseValue;
4826 // LDKCResult_RecoverableSignatureNoneZ NodeSigner_sign_invoice LDKNodeSigner *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient
4828 export function NodeSigner_sign_invoice(this_arg: bigint, hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint {
4829 if(!isWasmInitialized) {
4830 throw new Error("initializeWasm() must be awaited first!");
4832 const nativeResponseValue = wasm.TS_NodeSigner_sign_invoice(this_arg, hrp_bytes, invoice_data, recipient);
4833 return nativeResponseValue;
4835 // LDKCResult_SchnorrSignatureNoneZ NodeSigner_sign_bolt12_invoice_request LDKNodeSigner *NONNULL_PTR this_arg, const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request
4837 export function NodeSigner_sign_bolt12_invoice_request(this_arg: bigint, invoice_request: bigint): bigint {
4838 if(!isWasmInitialized) {
4839 throw new Error("initializeWasm() must be awaited first!");
4841 const nativeResponseValue = wasm.TS_NodeSigner_sign_bolt12_invoice_request(this_arg, invoice_request);
4842 return nativeResponseValue;
4844 // LDKCResult_SchnorrSignatureNoneZ NodeSigner_sign_bolt12_invoice LDKNodeSigner *NONNULL_PTR this_arg, const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice
4846 export function NodeSigner_sign_bolt12_invoice(this_arg: bigint, invoice: bigint): bigint {
4847 if(!isWasmInitialized) {
4848 throw new Error("initializeWasm() must be awaited first!");
4850 const nativeResponseValue = wasm.TS_NodeSigner_sign_bolt12_invoice(this_arg, invoice);
4851 return nativeResponseValue;
4853 // LDKCResult_ECDSASignatureNoneZ NodeSigner_sign_gossip_message LDKNodeSigner *NONNULL_PTR this_arg, struct LDKUnsignedGossipMessage msg
4855 export function NodeSigner_sign_gossip_message(this_arg: bigint, msg: bigint): bigint {
4856 if(!isWasmInitialized) {
4857 throw new Error("initializeWasm() must be awaited first!");
4859 const nativeResponseValue = wasm.TS_NodeSigner_sign_gossip_message(this_arg, msg);
4860 return nativeResponseValue;
4863 export interface LDKSignerProvider {
4864 generate_channel_keys_id (inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number;
4865 derive_channel_signer (channel_value_satoshis: bigint, channel_keys_id: number): bigint;
4866 read_chan_signer (reader: number): bigint;
4867 get_destination_script (): bigint;
4868 get_shutdown_scriptpubkey (): bigint;
4872 export function LDKSignerProvider_new(impl: LDKSignerProvider): [bigint, number] {
4873 if(!isWasmInitialized) {
4874 throw new Error("initializeWasm() must be awaited first!");
4876 var new_obj_idx = js_objs.length;
4877 for (var i = 0; i < js_objs.length; i++) {
4878 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4880 js_objs[i] = new WeakRef(impl);
4881 return [wasm.TS_LDKSignerProvider_new(i), i];
4883 // LDKThirtyTwoBytes SignerProvider_generate_channel_keys_id LDKSignerProvider *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id
4885 export function SignerProvider_generate_channel_keys_id(this_arg: bigint, inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number {
4886 if(!isWasmInitialized) {
4887 throw new Error("initializeWasm() must be awaited first!");
4889 const nativeResponseValue = wasm.TS_SignerProvider_generate_channel_keys_id(this_arg, inbound, channel_value_satoshis, user_channel_id);
4890 return nativeResponseValue;
4892 // LDKWriteableEcdsaChannelSigner SignerProvider_derive_channel_signer LDKSignerProvider *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id
4894 export function SignerProvider_derive_channel_signer(this_arg: bigint, channel_value_satoshis: bigint, channel_keys_id: number): bigint {
4895 if(!isWasmInitialized) {
4896 throw new Error("initializeWasm() must be awaited first!");
4898 const nativeResponseValue = wasm.TS_SignerProvider_derive_channel_signer(this_arg, channel_value_satoshis, channel_keys_id);
4899 return nativeResponseValue;
4901 // LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider_read_chan_signer LDKSignerProvider *NONNULL_PTR this_arg, struct LDKu8slice reader
4903 export function SignerProvider_read_chan_signer(this_arg: bigint, reader: number): bigint {
4904 if(!isWasmInitialized) {
4905 throw new Error("initializeWasm() must be awaited first!");
4907 const nativeResponseValue = wasm.TS_SignerProvider_read_chan_signer(this_arg, reader);
4908 return nativeResponseValue;
4910 // LDKCResult_CVec_u8ZNoneZ SignerProvider_get_destination_script LDKSignerProvider *NONNULL_PTR this_arg
4912 export function SignerProvider_get_destination_script(this_arg: bigint): bigint {
4913 if(!isWasmInitialized) {
4914 throw new Error("initializeWasm() must be awaited first!");
4916 const nativeResponseValue = wasm.TS_SignerProvider_get_destination_script(this_arg);
4917 return nativeResponseValue;
4919 // LDKCResult_ShutdownScriptNoneZ SignerProvider_get_shutdown_scriptpubkey LDKSignerProvider *NONNULL_PTR this_arg
4921 export function SignerProvider_get_shutdown_scriptpubkey(this_arg: bigint): bigint {
4922 if(!isWasmInitialized) {
4923 throw new Error("initializeWasm() must be awaited first!");
4925 const nativeResponseValue = wasm.TS_SignerProvider_get_shutdown_scriptpubkey(this_arg);
4926 return nativeResponseValue;
4929 export interface LDKFeeEstimator {
4930 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
4934 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): [bigint, number] {
4935 if(!isWasmInitialized) {
4936 throw new Error("initializeWasm() must be awaited first!");
4938 var new_obj_idx = js_objs.length;
4939 for (var i = 0; i < js_objs.length; i++) {
4940 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4942 js_objs[i] = new WeakRef(impl);
4943 return [wasm.TS_LDKFeeEstimator_new(i), i];
4945 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
4947 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: bigint, confirmation_target: ConfirmationTarget): number {
4948 if(!isWasmInitialized) {
4949 throw new Error("initializeWasm() must be awaited first!");
4951 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
4952 return nativeResponseValue;
4955 export interface LDKRouter {
4956 find_route (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint;
4957 find_route_with_id (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint, _payment_hash: number, _payment_id: number): bigint;
4961 export function LDKRouter_new(impl: LDKRouter): [bigint, number] {
4962 if(!isWasmInitialized) {
4963 throw new Error("initializeWasm() must be awaited first!");
4965 var new_obj_idx = js_objs.length;
4966 for (var i = 0; i < js_objs.length; i++) {
4967 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4969 js_objs[i] = new WeakRef(impl);
4970 return [wasm.TS_LDKRouter_new(i), i];
4972 // 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
4974 export function Router_find_route(this_arg: bigint, payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint {
4975 if(!isWasmInitialized) {
4976 throw new Error("initializeWasm() must be awaited first!");
4978 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, first_hops, inflight_htlcs);
4979 return nativeResponseValue;
4981 // 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
4983 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 {
4984 if(!isWasmInitialized) {
4985 throw new Error("initializeWasm() must be awaited first!");
4987 const nativeResponseValue = wasm.TS_Router_find_route_with_id(this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
4988 return nativeResponseValue;
4990 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *NONNULL_PTR owner);
4992 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(owner: bigint): number {
4993 if(!isWasmInitialized) {
4994 throw new Error("initializeWasm() must be awaited first!");
4996 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(owner);
4997 return nativeResponseValue;
4999 // struct LDKChannelManager C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *NONNULL_PTR owner);
5001 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(owner: bigint): bigint {
5002 if(!isWasmInitialized) {
5003 throw new Error("initializeWasm() must be awaited first!");
5005 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(owner);
5006 return nativeResponseValue;
5008 // struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
5010 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(owner: bigint): bigint {
5011 if(!isWasmInitialized) {
5012 throw new Error("initializeWasm() must be awaited first!");
5014 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(owner);
5015 return nativeResponseValue;
5017 // struct LDKDecodeError CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
5019 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(owner: bigint): bigint {
5020 if(!isWasmInitialized) {
5021 throw new Error("initializeWasm() must be awaited first!");
5023 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(owner);
5024 return nativeResponseValue;
5027 export class LDKMaxDustHTLCExposure {
5028 protected constructor() {}
5031 export function LDKMaxDustHTLCExposure_ty_from_ptr(ptr: bigint): number {
5032 if(!isWasmInitialized) {
5033 throw new Error("initializeWasm() must be awaited first!");
5035 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_ty_from_ptr(ptr);
5036 return nativeResponseValue;
5039 export function LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat(ptr: bigint): bigint {
5040 if(!isWasmInitialized) {
5041 throw new Error("initializeWasm() must be awaited first!");
5043 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat(ptr);
5044 return nativeResponseValue;
5047 export function LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier(ptr: bigint): bigint {
5048 if(!isWasmInitialized) {
5049 throw new Error("initializeWasm() must be awaited first!");
5051 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier(ptr);
5052 return nativeResponseValue;
5054 // struct LDKMaxDustHTLCExposure CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner);
5056 export function CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(owner: bigint): bigint {
5057 if(!isWasmInitialized) {
5058 throw new Error("initializeWasm() must be awaited first!");
5060 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(owner);
5061 return nativeResponseValue;
5063 // struct LDKDecodeError CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner);
5065 export function CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(owner: bigint): bigint {
5066 if(!isWasmInitialized) {
5067 throw new Error("initializeWasm() must be awaited first!");
5069 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(owner);
5070 return nativeResponseValue;
5072 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
5074 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: bigint): bigint {
5075 if(!isWasmInitialized) {
5076 throw new Error("initializeWasm() must be awaited first!");
5078 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
5079 return nativeResponseValue;
5081 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
5083 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: bigint): bigint {
5084 if(!isWasmInitialized) {
5085 throw new Error("initializeWasm() must be awaited first!");
5087 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
5088 return nativeResponseValue;
5091 export class LDKCOption_MaxDustHTLCExposureZ {
5092 protected constructor() {}
5095 export function LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr(ptr: bigint): number {
5096 if(!isWasmInitialized) {
5097 throw new Error("initializeWasm() must be awaited first!");
5099 const nativeResponseValue = wasm.TS_LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr(ptr);
5100 return nativeResponseValue;
5103 export function LDKCOption_MaxDustHTLCExposureZ_Some_get_some(ptr: bigint): bigint {
5104 if(!isWasmInitialized) {
5105 throw new Error("initializeWasm() must be awaited first!");
5107 const nativeResponseValue = wasm.TS_LDKCOption_MaxDustHTLCExposureZ_Some_get_some(ptr);
5108 return nativeResponseValue;
5111 export class LDKCOption_APIErrorZ {
5112 protected constructor() {}
5115 export function LDKCOption_APIErrorZ_ty_from_ptr(ptr: bigint): number {
5116 if(!isWasmInitialized) {
5117 throw new Error("initializeWasm() must be awaited first!");
5119 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_ty_from_ptr(ptr);
5120 return nativeResponseValue;
5123 export function LDKCOption_APIErrorZ_Some_get_some(ptr: bigint): bigint {
5124 if(!isWasmInitialized) {
5125 throw new Error("initializeWasm() must be awaited first!");
5127 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_Some_get_some(ptr);
5128 return nativeResponseValue;
5130 // struct LDKCOption_APIErrorZ CResult_COption_APIErrorZDecodeErrorZ_get_ok(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
5132 export function CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner: bigint): bigint {
5133 if(!isWasmInitialized) {
5134 throw new Error("initializeWasm() must be awaited first!");
5136 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner);
5137 return nativeResponseValue;
5139 // struct LDKDecodeError CResult_COption_APIErrorZDecodeErrorZ_get_err(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
5141 export function CResult_COption_APIErrorZDecodeErrorZ_get_err(owner: bigint): bigint {
5142 if(!isWasmInitialized) {
5143 throw new Error("initializeWasm() must be awaited first!");
5145 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_err(owner);
5146 return nativeResponseValue;
5148 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
5150 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5151 if(!isWasmInitialized) {
5152 throw new Error("initializeWasm() must be awaited first!");
5154 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
5155 return nativeResponseValue;
5157 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
5159 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5160 if(!isWasmInitialized) {
5161 throw new Error("initializeWasm() must be awaited first!");
5163 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
5164 return nativeResponseValue;
5167 export class LDKCOption_MonitorEventZ {
5168 protected constructor() {}
5171 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: bigint): number {
5172 if(!isWasmInitialized) {
5173 throw new Error("initializeWasm() must be awaited first!");
5175 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
5176 return nativeResponseValue;
5179 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: bigint): bigint {
5180 if(!isWasmInitialized) {
5181 throw new Error("initializeWasm() must be awaited first!");
5183 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
5184 return nativeResponseValue;
5186 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
5188 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: bigint): bigint {
5189 if(!isWasmInitialized) {
5190 throw new Error("initializeWasm() must be awaited first!");
5192 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
5193 return nativeResponseValue;
5195 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
5197 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: bigint): bigint {
5198 if(!isWasmInitialized) {
5199 throw new Error("initializeWasm() must be awaited first!");
5201 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
5202 return nativeResponseValue;
5204 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
5206 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5207 if(!isWasmInitialized) {
5208 throw new Error("initializeWasm() must be awaited first!");
5210 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
5211 return nativeResponseValue;
5213 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
5215 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5216 if(!isWasmInitialized) {
5217 throw new Error("initializeWasm() must be awaited first!");
5219 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
5220 return nativeResponseValue;
5222 // struct LDKOutPoint C2Tuple_OutPointCVec_u8ZZ_get_a(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR owner);
5224 export function C2Tuple_OutPointCVec_u8ZZ_get_a(owner: bigint): bigint {
5225 if(!isWasmInitialized) {
5226 throw new Error("initializeWasm() must be awaited first!");
5228 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_get_a(owner);
5229 return nativeResponseValue;
5231 // struct LDKCVec_u8Z C2Tuple_OutPointCVec_u8ZZ_get_b(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR owner);
5233 export function C2Tuple_OutPointCVec_u8ZZ_get_b(owner: bigint): number {
5234 if(!isWasmInitialized) {
5235 throw new Error("initializeWasm() must be awaited first!");
5237 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_get_b(owner);
5238 return nativeResponseValue;
5240 // uint32_t C2Tuple_u32CVec_u8ZZ_get_a(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR owner);
5242 export function C2Tuple_u32CVec_u8ZZ_get_a(owner: bigint): number {
5243 if(!isWasmInitialized) {
5244 throw new Error("initializeWasm() must be awaited first!");
5246 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_get_a(owner);
5247 return nativeResponseValue;
5249 // struct LDKCVec_u8Z C2Tuple_u32CVec_u8ZZ_get_b(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR owner);
5251 export function C2Tuple_u32CVec_u8ZZ_get_b(owner: bigint): number {
5252 if(!isWasmInitialized) {
5253 throw new Error("initializeWasm() must be awaited first!");
5255 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_get_b(owner);
5256 return nativeResponseValue;
5258 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR owner);
5260 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(owner: bigint): number {
5261 if(!isWasmInitialized) {
5262 throw new Error("initializeWasm() must be awaited first!");
5264 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(owner);
5265 return nativeResponseValue;
5267 // struct LDKCVec_C2Tuple_u32CVec_u8ZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR owner);
5269 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(owner: bigint): number {
5270 if(!isWasmInitialized) {
5271 throw new Error("initializeWasm() must be awaited first!");
5273 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(owner);
5274 return nativeResponseValue;
5276 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
5278 export function C2Tuple_u32TxOutZ_get_a(owner: bigint): number {
5279 if(!isWasmInitialized) {
5280 throw new Error("initializeWasm() must be awaited first!");
5282 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
5283 return nativeResponseValue;
5285 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
5287 export function C2Tuple_u32TxOutZ_get_b(owner: bigint): bigint {
5288 if(!isWasmInitialized) {
5289 throw new Error("initializeWasm() must be awaited first!");
5291 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
5292 return nativeResponseValue;
5294 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
5296 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(owner: bigint): number {
5297 if(!isWasmInitialized) {
5298 throw new Error("initializeWasm() must be awaited first!");
5300 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
5301 return nativeResponseValue;
5303 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
5305 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(owner: bigint): number {
5306 if(!isWasmInitialized) {
5307 throw new Error("initializeWasm() must be awaited first!");
5309 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
5310 return nativeResponseValue;
5313 export class LDKBalance {
5314 protected constructor() {}
5317 export function LDKBalance_ty_from_ptr(ptr: bigint): number {
5318 if(!isWasmInitialized) {
5319 throw new Error("initializeWasm() must be awaited first!");
5321 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
5322 return nativeResponseValue;
5325 export function LDKBalance_ClaimableOnChannelClose_get_amount_satoshis(ptr: bigint): bigint {
5326 if(!isWasmInitialized) {
5327 throw new Error("initializeWasm() must be awaited first!");
5329 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_amount_satoshis(ptr);
5330 return nativeResponseValue;
5333 export function LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis(ptr: bigint): bigint {
5334 if(!isWasmInitialized) {
5335 throw new Error("initializeWasm() must be awaited first!");
5337 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis(ptr);
5338 return nativeResponseValue;
5341 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: bigint): number {
5342 if(!isWasmInitialized) {
5343 throw new Error("initializeWasm() must be awaited first!");
5345 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
5346 return nativeResponseValue;
5349 export function LDKBalance_ContentiousClaimable_get_amount_satoshis(ptr: bigint): bigint {
5350 if(!isWasmInitialized) {
5351 throw new Error("initializeWasm() must be awaited first!");
5353 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_amount_satoshis(ptr);
5354 return nativeResponseValue;
5357 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: bigint): number {
5358 if(!isWasmInitialized) {
5359 throw new Error("initializeWasm() must be awaited first!");
5361 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
5362 return nativeResponseValue;
5365 export function LDKBalance_ContentiousClaimable_get_payment_hash(ptr: bigint): number {
5366 if(!isWasmInitialized) {
5367 throw new Error("initializeWasm() must be awaited first!");
5369 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_payment_hash(ptr);
5370 return nativeResponseValue;
5373 export function LDKBalance_ContentiousClaimable_get_payment_preimage(ptr: bigint): number {
5374 if(!isWasmInitialized) {
5375 throw new Error("initializeWasm() must be awaited first!");
5377 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_payment_preimage(ptr);
5378 return nativeResponseValue;
5381 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis(ptr: bigint): bigint {
5382 if(!isWasmInitialized) {
5383 throw new Error("initializeWasm() must be awaited first!");
5385 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis(ptr);
5386 return nativeResponseValue;
5389 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr: bigint): number {
5390 if(!isWasmInitialized) {
5391 throw new Error("initializeWasm() must be awaited first!");
5393 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr);
5394 return nativeResponseValue;
5397 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash(ptr: bigint): number {
5398 if(!isWasmInitialized) {
5399 throw new Error("initializeWasm() must be awaited first!");
5401 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash(ptr);
5402 return nativeResponseValue;
5405 export function LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis(ptr: bigint): bigint {
5406 if(!isWasmInitialized) {
5407 throw new Error("initializeWasm() must be awaited first!");
5409 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis(ptr);
5410 return nativeResponseValue;
5413 export function LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr: bigint): number {
5414 if(!isWasmInitialized) {
5415 throw new Error("initializeWasm() must be awaited first!");
5417 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr);
5418 return nativeResponseValue;
5421 export function LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash(ptr: bigint): number {
5422 if(!isWasmInitialized) {
5423 throw new Error("initializeWasm() must be awaited first!");
5425 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash(ptr);
5426 return nativeResponseValue;
5429 export function LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis(ptr: bigint): bigint {
5430 if(!isWasmInitialized) {
5431 throw new Error("initializeWasm() must be awaited first!");
5433 const nativeResponseValue = wasm.TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis(ptr);
5434 return nativeResponseValue;
5436 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR owner);
5438 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(owner: bigint): number {
5439 if(!isWasmInitialized) {
5440 throw new Error("initializeWasm() must be awaited first!");
5442 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(owner);
5443 return nativeResponseValue;
5445 // struct LDKChannelMonitor C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR owner);
5447 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(owner: bigint): bigint {
5448 if(!isWasmInitialized) {
5449 throw new Error("initializeWasm() must be awaited first!");
5451 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(owner);
5452 return nativeResponseValue;
5454 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5456 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(owner: bigint): bigint {
5457 if(!isWasmInitialized) {
5458 throw new Error("initializeWasm() must be awaited first!");
5460 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(owner);
5461 return nativeResponseValue;
5463 // struct LDKDecodeError CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5465 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(owner: bigint): bigint {
5466 if(!isWasmInitialized) {
5467 throw new Error("initializeWasm() must be awaited first!");
5469 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(owner);
5470 return nativeResponseValue;
5473 export interface LDKType {
5475 debug_str (): number;
5480 export function LDKType_new(impl: LDKType): [bigint, number] {
5481 if(!isWasmInitialized) {
5482 throw new Error("initializeWasm() must be awaited first!");
5484 var new_obj_idx = js_objs.length;
5485 for (var i = 0; i < js_objs.length; i++) {
5486 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5488 js_objs[i] = new WeakRef(impl);
5489 return [wasm.TS_LDKType_new(i), i];
5491 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
5493 export function Type_type_id(this_arg: bigint): number {
5494 if(!isWasmInitialized) {
5495 throw new Error("initializeWasm() must be awaited first!");
5497 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
5498 return nativeResponseValue;
5500 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
5502 export function Type_debug_str(this_arg: bigint): number {
5503 if(!isWasmInitialized) {
5504 throw new Error("initializeWasm() must be awaited first!");
5506 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
5507 return nativeResponseValue;
5509 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
5511 export function Type_write(this_arg: bigint): number {
5512 if(!isWasmInitialized) {
5513 throw new Error("initializeWasm() must be awaited first!");
5515 const nativeResponseValue = wasm.TS_Type_write(this_arg);
5516 return nativeResponseValue;
5518 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5520 export function C2Tuple_PublicKeyTypeZ_get_a(owner: bigint): number {
5521 if(!isWasmInitialized) {
5522 throw new Error("initializeWasm() must be awaited first!");
5524 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
5525 return nativeResponseValue;
5527 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5529 export function C2Tuple_PublicKeyTypeZ_get_b(owner: bigint): bigint {
5530 if(!isWasmInitialized) {
5531 throw new Error("initializeWasm() must be awaited first!");
5533 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
5534 return nativeResponseValue;
5537 export interface LDKOnionMessageContents {
5538 tlv_type (): bigint;
5543 export function LDKOnionMessageContents_new(impl: LDKOnionMessageContents): [bigint, number] {
5544 if(!isWasmInitialized) {
5545 throw new Error("initializeWasm() must be awaited first!");
5547 var new_obj_idx = js_objs.length;
5548 for (var i = 0; i < js_objs.length; i++) {
5549 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5551 js_objs[i] = new WeakRef(impl);
5552 return [wasm.TS_LDKOnionMessageContents_new(i), i];
5554 // uint64_t OnionMessageContents_tlv_type LDKOnionMessageContents *NONNULL_PTR this_arg
5556 export function OnionMessageContents_tlv_type(this_arg: bigint): bigint {
5557 if(!isWasmInitialized) {
5558 throw new Error("initializeWasm() must be awaited first!");
5560 const nativeResponseValue = wasm.TS_OnionMessageContents_tlv_type(this_arg);
5561 return nativeResponseValue;
5563 // LDKCVec_u8Z OnionMessageContents_write LDKOnionMessageContents *NONNULL_PTR this_arg
5565 export function OnionMessageContents_write(this_arg: bigint): number {
5566 if(!isWasmInitialized) {
5567 throw new Error("initializeWasm() must be awaited first!");
5569 const nativeResponseValue = wasm.TS_OnionMessageContents_write(this_arg);
5570 return nativeResponseValue;
5573 export class LDKCOption_OnionMessageContentsZ {
5574 protected constructor() {}
5577 export function LDKCOption_OnionMessageContentsZ_ty_from_ptr(ptr: bigint): number {
5578 if(!isWasmInitialized) {
5579 throw new Error("initializeWasm() must be awaited first!");
5581 const nativeResponseValue = wasm.TS_LDKCOption_OnionMessageContentsZ_ty_from_ptr(ptr);
5582 return nativeResponseValue;
5585 export function LDKCOption_OnionMessageContentsZ_Some_get_some(ptr: bigint): bigint {
5586 if(!isWasmInitialized) {
5587 throw new Error("initializeWasm() must be awaited first!");
5589 const nativeResponseValue = wasm.TS_LDKCOption_OnionMessageContentsZ_Some_get_some(ptr);
5590 return nativeResponseValue;
5592 // struct LDKCOption_OnionMessageContentsZ CResult_COption_OnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5594 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_get_ok(owner: bigint): bigint {
5595 if(!isWasmInitialized) {
5596 throw new Error("initializeWasm() must be awaited first!");
5598 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_get_ok(owner);
5599 return nativeResponseValue;
5601 // struct LDKDecodeError CResult_COption_OnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5603 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_get_err(owner: bigint): bigint {
5604 if(!isWasmInitialized) {
5605 throw new Error("initializeWasm() must be awaited first!");
5607 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_get_err(owner);
5608 return nativeResponseValue;
5610 // struct LDKOnionMessageContents C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_a(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR owner);
5612 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_a(owner: bigint): bigint {
5613 if(!isWasmInitialized) {
5614 throw new Error("initializeWasm() must be awaited first!");
5616 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_a(owner);
5617 return nativeResponseValue;
5619 // struct LDKDestination C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_b(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR owner);
5621 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_b(owner: bigint): bigint {
5622 if(!isWasmInitialized) {
5623 throw new Error("initializeWasm() must be awaited first!");
5625 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_b(owner);
5626 return nativeResponseValue;
5628 // struct LDKBlindedPath C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_c(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR owner);
5630 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_c(owner: bigint): bigint {
5631 if(!isWasmInitialized) {
5632 throw new Error("initializeWasm() must be awaited first!");
5634 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_c(owner);
5635 return nativeResponseValue;
5638 export class LDKCOption_TypeZ {
5639 protected constructor() {}
5642 export function LDKCOption_TypeZ_ty_from_ptr(ptr: bigint): number {
5643 if(!isWasmInitialized) {
5644 throw new Error("initializeWasm() must be awaited first!");
5646 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
5647 return nativeResponseValue;
5650 export function LDKCOption_TypeZ_Some_get_some(ptr: bigint): bigint {
5651 if(!isWasmInitialized) {
5652 throw new Error("initializeWasm() must be awaited first!");
5654 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
5655 return nativeResponseValue;
5657 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
5659 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: bigint): bigint {
5660 if(!isWasmInitialized) {
5661 throw new Error("initializeWasm() must be awaited first!");
5663 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
5664 return nativeResponseValue;
5666 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
5668 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: bigint): bigint {
5669 if(!isWasmInitialized) {
5670 throw new Error("initializeWasm() must be awaited first!");
5672 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
5673 return nativeResponseValue;
5676 export class LDKCOption_SocketAddressZ {
5677 protected constructor() {}
5680 export function LDKCOption_SocketAddressZ_ty_from_ptr(ptr: bigint): number {
5681 if(!isWasmInitialized) {
5682 throw new Error("initializeWasm() must be awaited first!");
5684 const nativeResponseValue = wasm.TS_LDKCOption_SocketAddressZ_ty_from_ptr(ptr);
5685 return nativeResponseValue;
5688 export function LDKCOption_SocketAddressZ_Some_get_some(ptr: bigint): bigint {
5689 if(!isWasmInitialized) {
5690 throw new Error("initializeWasm() must be awaited first!");
5692 const nativeResponseValue = wasm.TS_LDKCOption_SocketAddressZ_Some_get_some(ptr);
5693 return nativeResponseValue;
5695 // struct LDKPublicKey C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR owner);
5697 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(owner: bigint): number {
5698 if(!isWasmInitialized) {
5699 throw new Error("initializeWasm() must be awaited first!");
5701 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(owner);
5702 return nativeResponseValue;
5704 // struct LDKCOption_SocketAddressZ C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR owner);
5706 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(owner: bigint): bigint {
5707 if(!isWasmInitialized) {
5708 throw new Error("initializeWasm() must be awaited first!");
5710 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(owner);
5711 return nativeResponseValue;
5713 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5715 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: bigint): number {
5716 if(!isWasmInitialized) {
5717 throw new Error("initializeWasm() must be awaited first!");
5719 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
5720 return nativeResponseValue;
5722 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
5724 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: bigint): bigint {
5725 if(!isWasmInitialized) {
5726 throw new Error("initializeWasm() must be awaited first!");
5728 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
5729 return nativeResponseValue;
5731 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5733 export function CResult_NonePeerHandleErrorZ_get_ok(owner: bigint): void {
5734 if(!isWasmInitialized) {
5735 throw new Error("initializeWasm() must be awaited first!");
5737 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
5738 // debug statements here
5740 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
5742 export function CResult_NonePeerHandleErrorZ_get_err(owner: bigint): bigint {
5743 if(!isWasmInitialized) {
5744 throw new Error("initializeWasm() must be awaited first!");
5746 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
5747 return nativeResponseValue;
5749 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5751 export function CResult_boolPeerHandleErrorZ_get_ok(owner: bigint): boolean {
5752 if(!isWasmInitialized) {
5753 throw new Error("initializeWasm() must be awaited first!");
5755 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
5756 return nativeResponseValue;
5758 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
5760 export function CResult_boolPeerHandleErrorZ_get_err(owner: bigint): bigint {
5761 if(!isWasmInitialized) {
5762 throw new Error("initializeWasm() must be awaited first!");
5764 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
5765 return nativeResponseValue;
5768 export class LDKGraphSyncError {
5769 protected constructor() {}
5772 export function LDKGraphSyncError_ty_from_ptr(ptr: bigint): number {
5773 if(!isWasmInitialized) {
5774 throw new Error("initializeWasm() must be awaited first!");
5776 const nativeResponseValue = wasm.TS_LDKGraphSyncError_ty_from_ptr(ptr);
5777 return nativeResponseValue;
5780 export function LDKGraphSyncError_DecodeError_get_decode_error(ptr: bigint): bigint {
5781 if(!isWasmInitialized) {
5782 throw new Error("initializeWasm() must be awaited first!");
5784 const nativeResponseValue = wasm.TS_LDKGraphSyncError_DecodeError_get_decode_error(ptr);
5785 return nativeResponseValue;
5788 export function LDKGraphSyncError_LightningError_get_lightning_error(ptr: bigint): bigint {
5789 if(!isWasmInitialized) {
5790 throw new Error("initializeWasm() must be awaited first!");
5792 const nativeResponseValue = wasm.TS_LDKGraphSyncError_LightningError_get_lightning_error(ptr);
5793 return nativeResponseValue;
5795 // uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5797 export function CResult_u32GraphSyncErrorZ_get_ok(owner: bigint): number {
5798 if(!isWasmInitialized) {
5799 throw new Error("initializeWasm() must be awaited first!");
5801 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_ok(owner);
5802 return nativeResponseValue;
5804 // struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
5806 export function CResult_u32GraphSyncErrorZ_get_err(owner: bigint): bigint {
5807 if(!isWasmInitialized) {
5808 throw new Error("initializeWasm() must be awaited first!");
5810 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_err(owner);
5811 return nativeResponseValue;
5813 // struct LDKCVec_u8Z CResult_CVec_u8ZIOErrorZ_get_ok(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR owner);
5815 export function CResult_CVec_u8ZIOErrorZ_get_ok(owner: bigint): number {
5816 if(!isWasmInitialized) {
5817 throw new Error("initializeWasm() must be awaited first!");
5819 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_get_ok(owner);
5820 return nativeResponseValue;
5822 // enum LDKIOError CResult_CVec_u8ZIOErrorZ_get_err(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR owner);
5824 export function CResult_CVec_u8ZIOErrorZ_get_err(owner: bigint): IOError {
5825 if(!isWasmInitialized) {
5826 throw new Error("initializeWasm() must be awaited first!");
5828 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_get_err(owner);
5829 return nativeResponseValue;
5831 // void CResult_NoneIOErrorZ_get_ok(LDKCResult_NoneIOErrorZ *NONNULL_PTR owner);
5833 export function CResult_NoneIOErrorZ_get_ok(owner: bigint): void {
5834 if(!isWasmInitialized) {
5835 throw new Error("initializeWasm() must be awaited first!");
5837 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_get_ok(owner);
5838 // debug statements here
5840 // enum LDKIOError CResult_NoneIOErrorZ_get_err(LDKCResult_NoneIOErrorZ *NONNULL_PTR owner);
5842 export function CResult_NoneIOErrorZ_get_err(owner: bigint): IOError {
5843 if(!isWasmInitialized) {
5844 throw new Error("initializeWasm() must be awaited first!");
5846 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_get_err(owner);
5847 return nativeResponseValue;
5849 // struct LDKCVec_StrZ CResult_CVec_StrZIOErrorZ_get_ok(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR owner);
5851 export function CResult_CVec_StrZIOErrorZ_get_ok(owner: bigint): number {
5852 if(!isWasmInitialized) {
5853 throw new Error("initializeWasm() must be awaited first!");
5855 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_get_ok(owner);
5856 return nativeResponseValue;
5858 // enum LDKIOError CResult_CVec_StrZIOErrorZ_get_err(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR owner);
5860 export function CResult_CVec_StrZIOErrorZ_get_err(owner: bigint): IOError {
5861 if(!isWasmInitialized) {
5862 throw new Error("initializeWasm() must be awaited first!");
5864 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_get_err(owner);
5865 return nativeResponseValue;
5867 // struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR owner);
5869 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(owner: bigint): number {
5870 if(!isWasmInitialized) {
5871 throw new Error("initializeWasm() must be awaited first!");
5873 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(owner);
5874 return nativeResponseValue;
5876 // enum LDKIOError CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR owner);
5878 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(owner: bigint): IOError {
5879 if(!isWasmInitialized) {
5880 throw new Error("initializeWasm() must be awaited first!");
5882 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(owner);
5883 return nativeResponseValue;
5885 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR owner);
5887 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(owner: bigint): bigint {
5888 if(!isWasmInitialized) {
5889 throw new Error("initializeWasm() must be awaited first!");
5891 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(owner);
5892 return nativeResponseValue;
5894 // enum LDKIOError CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR owner);
5896 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(owner: bigint): IOError {
5897 if(!isWasmInitialized) {
5898 throw new Error("initializeWasm() must be awaited first!");
5900 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(owner);
5901 return nativeResponseValue;
5904 export class LDKCOption_SecretKeyZ {
5905 protected constructor() {}
5908 export function LDKCOption_SecretKeyZ_ty_from_ptr(ptr: bigint): number {
5909 if(!isWasmInitialized) {
5910 throw new Error("initializeWasm() must be awaited first!");
5912 const nativeResponseValue = wasm.TS_LDKCOption_SecretKeyZ_ty_from_ptr(ptr);
5913 return nativeResponseValue;
5916 export function LDKCOption_SecretKeyZ_Some_get_some(ptr: bigint): number {
5917 if(!isWasmInitialized) {
5918 throw new Error("initializeWasm() must be awaited first!");
5920 const nativeResponseValue = wasm.TS_LDKCOption_SecretKeyZ_Some_get_some(ptr);
5921 return nativeResponseValue;
5923 // struct LDKVerifiedInvoiceRequest CResult_VerifiedInvoiceRequestNoneZ_get_ok(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR owner);
5925 export function CResult_VerifiedInvoiceRequestNoneZ_get_ok(owner: bigint): bigint {
5926 if(!isWasmInitialized) {
5927 throw new Error("initializeWasm() must be awaited first!");
5929 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_get_ok(owner);
5930 return nativeResponseValue;
5932 // void CResult_VerifiedInvoiceRequestNoneZ_get_err(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR owner);
5934 export function CResult_VerifiedInvoiceRequestNoneZ_get_err(owner: bigint): void {
5935 if(!isWasmInitialized) {
5936 throw new Error("initializeWasm() must be awaited first!");
5938 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_get_err(owner);
5939 // debug statements here
5942 export class LDKCOption_i64Z {
5943 protected constructor() {}
5946 export function LDKCOption_i64Z_ty_from_ptr(ptr: bigint): number {
5947 if(!isWasmInitialized) {
5948 throw new Error("initializeWasm() must be awaited first!");
5950 const nativeResponseValue = wasm.TS_LDKCOption_i64Z_ty_from_ptr(ptr);
5951 return nativeResponseValue;
5954 export function LDKCOption_i64Z_Some_get_some(ptr: bigint): bigint {
5955 if(!isWasmInitialized) {
5956 throw new Error("initializeWasm() must be awaited first!");
5958 const nativeResponseValue = wasm.TS_LDKCOption_i64Z_Some_get_some(ptr);
5959 return nativeResponseValue;
5961 // struct LDKSocketAddress CResult_SocketAddressDecodeErrorZ_get_ok(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR owner);
5963 export function CResult_SocketAddressDecodeErrorZ_get_ok(owner: bigint): bigint {
5964 if(!isWasmInitialized) {
5965 throw new Error("initializeWasm() must be awaited first!");
5967 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_get_ok(owner);
5968 return nativeResponseValue;
5970 // struct LDKDecodeError CResult_SocketAddressDecodeErrorZ_get_err(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR owner);
5972 export function CResult_SocketAddressDecodeErrorZ_get_err(owner: bigint): bigint {
5973 if(!isWasmInitialized) {
5974 throw new Error("initializeWasm() must be awaited first!");
5976 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_get_err(owner);
5977 return nativeResponseValue;
5979 // struct LDKSocketAddress CResult_SocketAddressSocketAddressParseErrorZ_get_ok(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR owner);
5981 export function CResult_SocketAddressSocketAddressParseErrorZ_get_ok(owner: bigint): bigint {
5982 if(!isWasmInitialized) {
5983 throw new Error("initializeWasm() must be awaited first!");
5985 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_get_ok(owner);
5986 return nativeResponseValue;
5988 // enum LDKSocketAddressParseError CResult_SocketAddressSocketAddressParseErrorZ_get_err(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR owner);
5990 export function CResult_SocketAddressSocketAddressParseErrorZ_get_err(owner: bigint): SocketAddressParseError {
5991 if(!isWasmInitialized) {
5992 throw new Error("initializeWasm() must be awaited first!");
5994 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_get_err(owner);
5995 return nativeResponseValue;
5997 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5999 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
6000 if(!isWasmInitialized) {
6001 throw new Error("initializeWasm() must be awaited first!");
6003 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
6004 return nativeResponseValue;
6006 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
6008 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: bigint): bigint {
6009 if(!isWasmInitialized) {
6010 throw new Error("initializeWasm() must be awaited first!");
6012 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
6013 return nativeResponseValue;
6015 // struct LDKAcceptChannelV2 CResult_AcceptChannelV2DecodeErrorZ_get_ok(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner);
6017 export function CResult_AcceptChannelV2DecodeErrorZ_get_ok(owner: bigint): bigint {
6018 if(!isWasmInitialized) {
6019 throw new Error("initializeWasm() must be awaited first!");
6021 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_get_ok(owner);
6022 return nativeResponseValue;
6024 // struct LDKDecodeError CResult_AcceptChannelV2DecodeErrorZ_get_err(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner);
6026 export function CResult_AcceptChannelV2DecodeErrorZ_get_err(owner: bigint): bigint {
6027 if(!isWasmInitialized) {
6028 throw new Error("initializeWasm() must be awaited first!");
6030 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_get_err(owner);
6031 return nativeResponseValue;
6033 // struct LDKTxAddInput CResult_TxAddInputDecodeErrorZ_get_ok(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner);
6035 export function CResult_TxAddInputDecodeErrorZ_get_ok(owner: bigint): bigint {
6036 if(!isWasmInitialized) {
6037 throw new Error("initializeWasm() must be awaited first!");
6039 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_get_ok(owner);
6040 return nativeResponseValue;
6042 // struct LDKDecodeError CResult_TxAddInputDecodeErrorZ_get_err(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner);
6044 export function CResult_TxAddInputDecodeErrorZ_get_err(owner: bigint): bigint {
6045 if(!isWasmInitialized) {
6046 throw new Error("initializeWasm() must be awaited first!");
6048 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_get_err(owner);
6049 return nativeResponseValue;
6051 // struct LDKTxAddOutput CResult_TxAddOutputDecodeErrorZ_get_ok(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner);
6053 export function CResult_TxAddOutputDecodeErrorZ_get_ok(owner: bigint): bigint {
6054 if(!isWasmInitialized) {
6055 throw new Error("initializeWasm() must be awaited first!");
6057 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_get_ok(owner);
6058 return nativeResponseValue;
6060 // struct LDKDecodeError CResult_TxAddOutputDecodeErrorZ_get_err(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner);
6062 export function CResult_TxAddOutputDecodeErrorZ_get_err(owner: bigint): bigint {
6063 if(!isWasmInitialized) {
6064 throw new Error("initializeWasm() must be awaited first!");
6066 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_get_err(owner);
6067 return nativeResponseValue;
6069 // struct LDKTxRemoveInput CResult_TxRemoveInputDecodeErrorZ_get_ok(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner);
6071 export function CResult_TxRemoveInputDecodeErrorZ_get_ok(owner: bigint): bigint {
6072 if(!isWasmInitialized) {
6073 throw new Error("initializeWasm() must be awaited first!");
6075 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_get_ok(owner);
6076 return nativeResponseValue;
6078 // struct LDKDecodeError CResult_TxRemoveInputDecodeErrorZ_get_err(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner);
6080 export function CResult_TxRemoveInputDecodeErrorZ_get_err(owner: bigint): bigint {
6081 if(!isWasmInitialized) {
6082 throw new Error("initializeWasm() must be awaited first!");
6084 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_get_err(owner);
6085 return nativeResponseValue;
6087 // struct LDKTxRemoveOutput CResult_TxRemoveOutputDecodeErrorZ_get_ok(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner);
6089 export function CResult_TxRemoveOutputDecodeErrorZ_get_ok(owner: bigint): bigint {
6090 if(!isWasmInitialized) {
6091 throw new Error("initializeWasm() must be awaited first!");
6093 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_get_ok(owner);
6094 return nativeResponseValue;
6096 // struct LDKDecodeError CResult_TxRemoveOutputDecodeErrorZ_get_err(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner);
6098 export function CResult_TxRemoveOutputDecodeErrorZ_get_err(owner: bigint): bigint {
6099 if(!isWasmInitialized) {
6100 throw new Error("initializeWasm() must be awaited first!");
6102 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_get_err(owner);
6103 return nativeResponseValue;
6105 // struct LDKTxComplete CResult_TxCompleteDecodeErrorZ_get_ok(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner);
6107 export function CResult_TxCompleteDecodeErrorZ_get_ok(owner: bigint): bigint {
6108 if(!isWasmInitialized) {
6109 throw new Error("initializeWasm() must be awaited first!");
6111 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_get_ok(owner);
6112 return nativeResponseValue;
6114 // struct LDKDecodeError CResult_TxCompleteDecodeErrorZ_get_err(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner);
6116 export function CResult_TxCompleteDecodeErrorZ_get_err(owner: bigint): bigint {
6117 if(!isWasmInitialized) {
6118 throw new Error("initializeWasm() must be awaited first!");
6120 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_get_err(owner);
6121 return nativeResponseValue;
6123 // struct LDKTxSignatures CResult_TxSignaturesDecodeErrorZ_get_ok(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner);
6125 export function CResult_TxSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
6126 if(!isWasmInitialized) {
6127 throw new Error("initializeWasm() must be awaited first!");
6129 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_get_ok(owner);
6130 return nativeResponseValue;
6132 // struct LDKDecodeError CResult_TxSignaturesDecodeErrorZ_get_err(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner);
6134 export function CResult_TxSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
6135 if(!isWasmInitialized) {
6136 throw new Error("initializeWasm() must be awaited first!");
6138 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_get_err(owner);
6139 return nativeResponseValue;
6141 // struct LDKTxInitRbf CResult_TxInitRbfDecodeErrorZ_get_ok(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner);
6143 export function CResult_TxInitRbfDecodeErrorZ_get_ok(owner: bigint): bigint {
6144 if(!isWasmInitialized) {
6145 throw new Error("initializeWasm() must be awaited first!");
6147 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_get_ok(owner);
6148 return nativeResponseValue;
6150 // struct LDKDecodeError CResult_TxInitRbfDecodeErrorZ_get_err(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner);
6152 export function CResult_TxInitRbfDecodeErrorZ_get_err(owner: bigint): bigint {
6153 if(!isWasmInitialized) {
6154 throw new Error("initializeWasm() must be awaited first!");
6156 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_get_err(owner);
6157 return nativeResponseValue;
6159 // struct LDKTxAckRbf CResult_TxAckRbfDecodeErrorZ_get_ok(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner);
6161 export function CResult_TxAckRbfDecodeErrorZ_get_ok(owner: bigint): bigint {
6162 if(!isWasmInitialized) {
6163 throw new Error("initializeWasm() must be awaited first!");
6165 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_get_ok(owner);
6166 return nativeResponseValue;
6168 // struct LDKDecodeError CResult_TxAckRbfDecodeErrorZ_get_err(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner);
6170 export function CResult_TxAckRbfDecodeErrorZ_get_err(owner: bigint): bigint {
6171 if(!isWasmInitialized) {
6172 throw new Error("initializeWasm() must be awaited first!");
6174 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_get_err(owner);
6175 return nativeResponseValue;
6177 // struct LDKTxAbort CResult_TxAbortDecodeErrorZ_get_ok(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner);
6179 export function CResult_TxAbortDecodeErrorZ_get_ok(owner: bigint): bigint {
6180 if(!isWasmInitialized) {
6181 throw new Error("initializeWasm() must be awaited first!");
6183 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_get_ok(owner);
6184 return nativeResponseValue;
6186 // struct LDKDecodeError CResult_TxAbortDecodeErrorZ_get_err(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner);
6188 export function CResult_TxAbortDecodeErrorZ_get_err(owner: bigint): bigint {
6189 if(!isWasmInitialized) {
6190 throw new Error("initializeWasm() must be awaited first!");
6192 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_get_err(owner);
6193 return nativeResponseValue;
6195 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
6197 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
6198 if(!isWasmInitialized) {
6199 throw new Error("initializeWasm() must be awaited first!");
6201 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
6202 return nativeResponseValue;
6204 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
6206 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
6207 if(!isWasmInitialized) {
6208 throw new Error("initializeWasm() must be awaited first!");
6210 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
6211 return nativeResponseValue;
6213 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
6215 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: bigint): bigint {
6216 if(!isWasmInitialized) {
6217 throw new Error("initializeWasm() must be awaited first!");
6219 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
6220 return nativeResponseValue;
6222 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
6224 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: bigint): bigint {
6225 if(!isWasmInitialized) {
6226 throw new Error("initializeWasm() must be awaited first!");
6228 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
6229 return nativeResponseValue;
6231 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
6233 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6234 if(!isWasmInitialized) {
6235 throw new Error("initializeWasm() must be awaited first!");
6237 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
6238 return nativeResponseValue;
6240 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
6242 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6243 if(!isWasmInitialized) {
6244 throw new Error("initializeWasm() must be awaited first!");
6246 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
6247 return nativeResponseValue;
6249 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
6251 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6252 if(!isWasmInitialized) {
6253 throw new Error("initializeWasm() must be awaited first!");
6255 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
6256 return nativeResponseValue;
6258 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
6260 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6261 if(!isWasmInitialized) {
6262 throw new Error("initializeWasm() must be awaited first!");
6264 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
6265 return nativeResponseValue;
6267 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
6269 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6270 if(!isWasmInitialized) {
6271 throw new Error("initializeWasm() must be awaited first!");
6273 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
6274 return nativeResponseValue;
6276 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
6278 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6279 if(!isWasmInitialized) {
6280 throw new Error("initializeWasm() must be awaited first!");
6282 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
6283 return nativeResponseValue;
6285 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
6287 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: bigint): bigint {
6288 if(!isWasmInitialized) {
6289 throw new Error("initializeWasm() must be awaited first!");
6291 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
6292 return nativeResponseValue;
6294 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
6296 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: bigint): bigint {
6297 if(!isWasmInitialized) {
6298 throw new Error("initializeWasm() must be awaited first!");
6300 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
6301 return nativeResponseValue;
6303 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
6305 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6306 if(!isWasmInitialized) {
6307 throw new Error("initializeWasm() must be awaited first!");
6309 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
6310 return nativeResponseValue;
6312 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
6314 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6315 if(!isWasmInitialized) {
6316 throw new Error("initializeWasm() must be awaited first!");
6318 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
6319 return nativeResponseValue;
6321 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
6323 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: bigint): bigint {
6324 if(!isWasmInitialized) {
6325 throw new Error("initializeWasm() must be awaited first!");
6327 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
6328 return nativeResponseValue;
6330 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
6332 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: bigint): bigint {
6333 if(!isWasmInitialized) {
6334 throw new Error("initializeWasm() must be awaited first!");
6336 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
6337 return nativeResponseValue;
6339 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
6341 export function CResult_InitDecodeErrorZ_get_ok(owner: bigint): bigint {
6342 if(!isWasmInitialized) {
6343 throw new Error("initializeWasm() must be awaited first!");
6345 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
6346 return nativeResponseValue;
6348 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
6350 export function CResult_InitDecodeErrorZ_get_err(owner: bigint): bigint {
6351 if(!isWasmInitialized) {
6352 throw new Error("initializeWasm() must be awaited first!");
6354 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
6355 return nativeResponseValue;
6357 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
6359 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
6360 if(!isWasmInitialized) {
6361 throw new Error("initializeWasm() must be awaited first!");
6363 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
6364 return nativeResponseValue;
6366 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
6368 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: bigint): bigint {
6369 if(!isWasmInitialized) {
6370 throw new Error("initializeWasm() must be awaited first!");
6372 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
6373 return nativeResponseValue;
6375 // struct LDKOpenChannelV2 CResult_OpenChannelV2DecodeErrorZ_get_ok(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner);
6377 export function CResult_OpenChannelV2DecodeErrorZ_get_ok(owner: bigint): bigint {
6378 if(!isWasmInitialized) {
6379 throw new Error("initializeWasm() must be awaited first!");
6381 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_get_ok(owner);
6382 return nativeResponseValue;
6384 // struct LDKDecodeError CResult_OpenChannelV2DecodeErrorZ_get_err(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner);
6386 export function CResult_OpenChannelV2DecodeErrorZ_get_err(owner: bigint): bigint {
6387 if(!isWasmInitialized) {
6388 throw new Error("initializeWasm() must be awaited first!");
6390 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_get_err(owner);
6391 return nativeResponseValue;
6393 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
6395 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: bigint): bigint {
6396 if(!isWasmInitialized) {
6397 throw new Error("initializeWasm() must be awaited first!");
6399 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
6400 return nativeResponseValue;
6402 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
6404 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: bigint): bigint {
6405 if(!isWasmInitialized) {
6406 throw new Error("initializeWasm() must be awaited first!");
6408 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
6409 return nativeResponseValue;
6411 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
6413 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: bigint): bigint {
6414 if(!isWasmInitialized) {
6415 throw new Error("initializeWasm() must be awaited first!");
6417 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
6418 return nativeResponseValue;
6420 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
6422 export function CResult_ShutdownDecodeErrorZ_get_err(owner: bigint): bigint {
6423 if(!isWasmInitialized) {
6424 throw new Error("initializeWasm() must be awaited first!");
6426 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
6427 return nativeResponseValue;
6429 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
6431 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6432 if(!isWasmInitialized) {
6433 throw new Error("initializeWasm() must be awaited first!");
6435 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
6436 return nativeResponseValue;
6438 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
6440 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6441 if(!isWasmInitialized) {
6442 throw new Error("initializeWasm() must be awaited first!");
6444 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
6445 return nativeResponseValue;
6447 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
6449 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6450 if(!isWasmInitialized) {
6451 throw new Error("initializeWasm() must be awaited first!");
6453 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
6454 return nativeResponseValue;
6456 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
6458 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6459 if(!isWasmInitialized) {
6460 throw new Error("initializeWasm() must be awaited first!");
6462 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
6463 return nativeResponseValue;
6465 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
6467 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: bigint): bigint {
6468 if(!isWasmInitialized) {
6469 throw new Error("initializeWasm() must be awaited first!");
6471 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
6472 return nativeResponseValue;
6474 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
6476 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: bigint): bigint {
6477 if(!isWasmInitialized) {
6478 throw new Error("initializeWasm() must be awaited first!");
6480 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
6481 return nativeResponseValue;
6483 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
6485 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6486 if(!isWasmInitialized) {
6487 throw new Error("initializeWasm() must be awaited first!");
6489 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
6490 return nativeResponseValue;
6492 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
6494 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6495 if(!isWasmInitialized) {
6496 throw new Error("initializeWasm() must be awaited first!");
6498 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
6499 return nativeResponseValue;
6501 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
6503 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6504 if(!isWasmInitialized) {
6505 throw new Error("initializeWasm() must be awaited first!");
6507 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
6508 return nativeResponseValue;
6510 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
6512 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6513 if(!isWasmInitialized) {
6514 throw new Error("initializeWasm() must be awaited first!");
6516 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
6517 return nativeResponseValue;
6519 // struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
6521 export function CResult_OnionMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6522 if(!isWasmInitialized) {
6523 throw new Error("initializeWasm() must be awaited first!");
6525 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_ok(owner);
6526 return nativeResponseValue;
6528 // struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
6530 export function CResult_OnionMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6531 if(!isWasmInitialized) {
6532 throw new Error("initializeWasm() must be awaited first!");
6534 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_err(owner);
6535 return nativeResponseValue;
6537 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
6539 export function CResult_PingDecodeErrorZ_get_ok(owner: bigint): bigint {
6540 if(!isWasmInitialized) {
6541 throw new Error("initializeWasm() must be awaited first!");
6543 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
6544 return nativeResponseValue;
6546 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
6548 export function CResult_PingDecodeErrorZ_get_err(owner: bigint): bigint {
6549 if(!isWasmInitialized) {
6550 throw new Error("initializeWasm() must be awaited first!");
6552 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
6553 return nativeResponseValue;
6555 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
6557 export function CResult_PongDecodeErrorZ_get_ok(owner: bigint): bigint {
6558 if(!isWasmInitialized) {
6559 throw new Error("initializeWasm() must be awaited first!");
6561 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
6562 return nativeResponseValue;
6564 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
6566 export function CResult_PongDecodeErrorZ_get_err(owner: bigint): bigint {
6567 if(!isWasmInitialized) {
6568 throw new Error("initializeWasm() must be awaited first!");
6570 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
6571 return nativeResponseValue;
6573 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6575 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6576 if(!isWasmInitialized) {
6577 throw new Error("initializeWasm() must be awaited first!");
6579 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
6580 return nativeResponseValue;
6582 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6584 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6585 if(!isWasmInitialized) {
6586 throw new Error("initializeWasm() must be awaited first!");
6588 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
6589 return nativeResponseValue;
6591 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6593 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6594 if(!isWasmInitialized) {
6595 throw new Error("initializeWasm() must be awaited first!");
6597 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
6598 return nativeResponseValue;
6600 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6602 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6603 if(!isWasmInitialized) {
6604 throw new Error("initializeWasm() must be awaited first!");
6606 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
6607 return nativeResponseValue;
6609 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6611 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
6612 if(!isWasmInitialized) {
6613 throw new Error("initializeWasm() must be awaited first!");
6615 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
6616 return nativeResponseValue;
6618 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6620 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6621 if(!isWasmInitialized) {
6622 throw new Error("initializeWasm() must be awaited first!");
6624 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
6625 return nativeResponseValue;
6627 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6629 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
6630 if(!isWasmInitialized) {
6631 throw new Error("initializeWasm() must be awaited first!");
6633 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
6634 return nativeResponseValue;
6636 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
6638 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
6639 if(!isWasmInitialized) {
6640 throw new Error("initializeWasm() must be awaited first!");
6642 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
6643 return nativeResponseValue;
6645 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
6647 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6648 if(!isWasmInitialized) {
6649 throw new Error("initializeWasm() must be awaited first!");
6651 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
6652 return nativeResponseValue;
6654 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
6656 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6657 if(!isWasmInitialized) {
6658 throw new Error("initializeWasm() must be awaited first!");
6660 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
6661 return nativeResponseValue;
6663 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
6665 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6666 if(!isWasmInitialized) {
6667 throw new Error("initializeWasm() must be awaited first!");
6669 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
6670 return nativeResponseValue;
6672 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
6674 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6675 if(!isWasmInitialized) {
6676 throw new Error("initializeWasm() must be awaited first!");
6678 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
6679 return nativeResponseValue;
6681 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6683 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6684 if(!isWasmInitialized) {
6685 throw new Error("initializeWasm() must be awaited first!");
6687 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
6688 return nativeResponseValue;
6690 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6692 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6693 if(!isWasmInitialized) {
6694 throw new Error("initializeWasm() must be awaited first!");
6696 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
6697 return nativeResponseValue;
6699 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6701 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
6702 if(!isWasmInitialized) {
6703 throw new Error("initializeWasm() must be awaited first!");
6705 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
6706 return nativeResponseValue;
6708 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
6710 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
6711 if(!isWasmInitialized) {
6712 throw new Error("initializeWasm() must be awaited first!");
6714 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
6715 return nativeResponseValue;
6717 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
6719 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: bigint): bigint {
6720 if(!isWasmInitialized) {
6721 throw new Error("initializeWasm() must be awaited first!");
6723 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
6724 return nativeResponseValue;
6726 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
6728 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: bigint): bigint {
6729 if(!isWasmInitialized) {
6730 throw new Error("initializeWasm() must be awaited first!");
6732 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
6733 return nativeResponseValue;
6735 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
6737 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: bigint): bigint {
6738 if(!isWasmInitialized) {
6739 throw new Error("initializeWasm() must be awaited first!");
6741 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
6742 return nativeResponseValue;
6744 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
6746 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: bigint): bigint {
6747 if(!isWasmInitialized) {
6748 throw new Error("initializeWasm() must be awaited first!");
6750 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
6751 return nativeResponseValue;
6753 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6755 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6756 if(!isWasmInitialized) {
6757 throw new Error("initializeWasm() must be awaited first!");
6759 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
6760 return nativeResponseValue;
6762 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6764 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6765 if(!isWasmInitialized) {
6766 throw new Error("initializeWasm() must be awaited first!");
6768 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
6769 return nativeResponseValue;
6771 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6773 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6774 if(!isWasmInitialized) {
6775 throw new Error("initializeWasm() must be awaited first!");
6777 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
6778 return nativeResponseValue;
6780 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
6782 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6783 if(!isWasmInitialized) {
6784 throw new Error("initializeWasm() must be awaited first!");
6786 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
6787 return nativeResponseValue;
6789 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
6791 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: bigint): bigint {
6792 if(!isWasmInitialized) {
6793 throw new Error("initializeWasm() must be awaited first!");
6795 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
6796 return nativeResponseValue;
6798 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
6800 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: bigint): bigint {
6801 if(!isWasmInitialized) {
6802 throw new Error("initializeWasm() must be awaited first!");
6804 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
6805 return nativeResponseValue;
6808 export class LDKSignOrCreationError {
6809 protected constructor() {}
6812 export function LDKSignOrCreationError_ty_from_ptr(ptr: bigint): number {
6813 if(!isWasmInitialized) {
6814 throw new Error("initializeWasm() must be awaited first!");
6816 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
6817 return nativeResponseValue;
6820 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: bigint): CreationError {
6821 if(!isWasmInitialized) {
6822 throw new Error("initializeWasm() must be awaited first!");
6824 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
6825 return nativeResponseValue;
6827 // struct LDKBolt11Invoice CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
6829 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(owner: bigint): bigint {
6830 if(!isWasmInitialized) {
6831 throw new Error("initializeWasm() must be awaited first!");
6833 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(owner);
6834 return nativeResponseValue;
6836 // struct LDKSignOrCreationError CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
6838 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner: bigint): bigint {
6839 if(!isWasmInitialized) {
6840 throw new Error("initializeWasm() must be awaited first!");
6842 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner);
6843 return nativeResponseValue;
6845 // struct LDKOffersMessage CResult_OffersMessageDecodeErrorZ_get_ok(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner);
6847 export function CResult_OffersMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6848 if(!isWasmInitialized) {
6849 throw new Error("initializeWasm() must be awaited first!");
6851 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_get_ok(owner);
6852 return nativeResponseValue;
6854 // struct LDKDecodeError CResult_OffersMessageDecodeErrorZ_get_err(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner);
6856 export function CResult_OffersMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6857 if(!isWasmInitialized) {
6858 throw new Error("initializeWasm() must be awaited first!");
6860 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_get_err(owner);
6861 return nativeResponseValue;
6864 export class LDKCOption_HTLCClaimZ {
6865 protected constructor() {}
6868 export function LDKCOption_HTLCClaimZ_ty_from_ptr(ptr: bigint): number {
6869 if(!isWasmInitialized) {
6870 throw new Error("initializeWasm() must be awaited first!");
6872 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_ty_from_ptr(ptr);
6873 return nativeResponseValue;
6876 export function LDKCOption_HTLCClaimZ_Some_get_some(ptr: bigint): HTLCClaim {
6877 if(!isWasmInitialized) {
6878 throw new Error("initializeWasm() must be awaited first!");
6880 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_Some_get_some(ptr);
6881 return nativeResponseValue;
6883 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
6885 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: bigint): bigint {
6886 if(!isWasmInitialized) {
6887 throw new Error("initializeWasm() must be awaited first!");
6889 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
6890 return nativeResponseValue;
6892 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
6894 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: bigint): bigint {
6895 if(!isWasmInitialized) {
6896 throw new Error("initializeWasm() must be awaited first!");
6898 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
6899 return nativeResponseValue;
6901 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
6903 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
6904 if(!isWasmInitialized) {
6905 throw new Error("initializeWasm() must be awaited first!");
6907 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
6908 return nativeResponseValue;
6910 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
6912 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: bigint): bigint {
6913 if(!isWasmInitialized) {
6914 throw new Error("initializeWasm() must be awaited first!");
6916 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
6917 return nativeResponseValue;
6919 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
6921 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
6922 if(!isWasmInitialized) {
6923 throw new Error("initializeWasm() must be awaited first!");
6925 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
6926 return nativeResponseValue;
6928 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
6930 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: bigint): bigint {
6931 if(!isWasmInitialized) {
6932 throw new Error("initializeWasm() must be awaited first!");
6934 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
6935 return nativeResponseValue;
6937 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
6939 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: bigint): bigint {
6940 if(!isWasmInitialized) {
6941 throw new Error("initializeWasm() must be awaited first!");
6943 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
6944 return nativeResponseValue;
6946 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
6948 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: bigint): bigint {
6949 if(!isWasmInitialized) {
6950 throw new Error("initializeWasm() must be awaited first!");
6952 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
6953 return nativeResponseValue;
6955 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
6957 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
6958 if(!isWasmInitialized) {
6959 throw new Error("initializeWasm() must be awaited first!");
6961 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
6962 return nativeResponseValue;
6964 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
6966 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
6967 if(!isWasmInitialized) {
6968 throw new Error("initializeWasm() must be awaited first!");
6970 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
6971 return nativeResponseValue;
6973 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
6975 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
6976 if(!isWasmInitialized) {
6977 throw new Error("initializeWasm() must be awaited first!");
6979 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
6980 return nativeResponseValue;
6982 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
6984 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
6985 if(!isWasmInitialized) {
6986 throw new Error("initializeWasm() must be awaited first!");
6988 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
6989 return nativeResponseValue;
6991 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
6993 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
6994 if(!isWasmInitialized) {
6995 throw new Error("initializeWasm() must be awaited first!");
6997 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
6998 return nativeResponseValue;
7000 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
7002 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
7003 if(!isWasmInitialized) {
7004 throw new Error("initializeWasm() must be awaited first!");
7006 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
7007 return nativeResponseValue;
7009 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
7011 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
7012 if(!isWasmInitialized) {
7013 throw new Error("initializeWasm() must be awaited first!");
7015 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
7016 return nativeResponseValue;
7018 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
7020 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
7021 if(!isWasmInitialized) {
7022 throw new Error("initializeWasm() must be awaited first!");
7024 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
7025 return nativeResponseValue;
7027 // struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
7029 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: bigint): bigint {
7030 if(!isWasmInitialized) {
7031 throw new Error("initializeWasm() must be awaited first!");
7033 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
7034 return nativeResponseValue;
7036 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
7038 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: bigint): void {
7039 if(!isWasmInitialized) {
7040 throw new Error("initializeWasm() must be awaited first!");
7042 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
7043 // debug statements here
7045 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
7047 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
7048 if(!isWasmInitialized) {
7049 throw new Error("initializeWasm() must be awaited first!");
7051 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
7052 return nativeResponseValue;
7054 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
7056 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
7057 if(!isWasmInitialized) {
7058 throw new Error("initializeWasm() must be awaited first!");
7060 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
7061 return nativeResponseValue;
7063 // struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
7065 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: bigint): bigint {
7066 if(!isWasmInitialized) {
7067 throw new Error("initializeWasm() must be awaited first!");
7069 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
7070 return nativeResponseValue;
7072 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
7074 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: bigint): void {
7075 if(!isWasmInitialized) {
7076 throw new Error("initializeWasm() must be awaited first!");
7078 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
7079 // debug statements here
7081 // struct LDKCVec_ECDSASignatureZ CResult_CVec_ECDSASignatureZNoneZ_get_ok(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR owner);
7083 export function CResult_CVec_ECDSASignatureZNoneZ_get_ok(owner: bigint): number {
7084 if(!isWasmInitialized) {
7085 throw new Error("initializeWasm() must be awaited first!");
7087 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_get_ok(owner);
7088 return nativeResponseValue;
7090 // void CResult_CVec_ECDSASignatureZNoneZ_get_err(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR owner);
7092 export function CResult_CVec_ECDSASignatureZNoneZ_get_err(owner: bigint): void {
7093 if(!isWasmInitialized) {
7094 throw new Error("initializeWasm() must be awaited first!");
7096 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_get_err(owner);
7097 // debug statements here
7100 export class LDKCOption_usizeZ {
7101 protected constructor() {}
7104 export function LDKCOption_usizeZ_ty_from_ptr(ptr: bigint): number {
7105 if(!isWasmInitialized) {
7106 throw new Error("initializeWasm() must be awaited first!");
7108 const nativeResponseValue = wasm.TS_LDKCOption_usizeZ_ty_from_ptr(ptr);
7109 return nativeResponseValue;
7112 export function LDKCOption_usizeZ_Some_get_some(ptr: bigint): number {
7113 if(!isWasmInitialized) {
7114 throw new Error("initializeWasm() must be awaited first!");
7116 const nativeResponseValue = wasm.TS_LDKCOption_usizeZ_Some_get_some(ptr);
7117 return nativeResponseValue;
7119 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
7121 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: bigint): bigint {
7122 if(!isWasmInitialized) {
7123 throw new Error("initializeWasm() must be awaited first!");
7125 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
7126 return nativeResponseValue;
7128 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
7130 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: bigint): bigint {
7131 if(!isWasmInitialized) {
7132 throw new Error("initializeWasm() must be awaited first!");
7134 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
7135 return nativeResponseValue;
7137 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
7139 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: bigint): bigint {
7140 if(!isWasmInitialized) {
7141 throw new Error("initializeWasm() must be awaited first!");
7143 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
7144 return nativeResponseValue;
7146 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
7148 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: bigint): bigint {
7149 if(!isWasmInitialized) {
7150 throw new Error("initializeWasm() must be awaited first!");
7152 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
7153 return nativeResponseValue;
7156 export class LDKPaymentPurpose {
7157 protected constructor() {}
7160 export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
7161 if(!isWasmInitialized) {
7162 throw new Error("initializeWasm() must be awaited first!");
7164 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
7165 return nativeResponseValue;
7168 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: bigint): bigint {
7169 if(!isWasmInitialized) {
7170 throw new Error("initializeWasm() must be awaited first!");
7172 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
7173 return nativeResponseValue;
7176 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: bigint): number {
7177 if(!isWasmInitialized) {
7178 throw new Error("initializeWasm() must be awaited first!");
7180 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
7181 return nativeResponseValue;
7184 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
7185 if(!isWasmInitialized) {
7186 throw new Error("initializeWasm() must be awaited first!");
7188 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
7189 return nativeResponseValue;
7191 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
7193 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
7194 if(!isWasmInitialized) {
7195 throw new Error("initializeWasm() must be awaited first!");
7197 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
7198 return nativeResponseValue;
7200 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
7202 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
7203 if(!isWasmInitialized) {
7204 throw new Error("initializeWasm() must be awaited first!");
7206 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
7207 return nativeResponseValue;
7209 // struct LDKClaimedHTLC CResult_ClaimedHTLCDecodeErrorZ_get_ok(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR owner);
7211 export function CResult_ClaimedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
7212 if(!isWasmInitialized) {
7213 throw new Error("initializeWasm() must be awaited first!");
7215 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_get_ok(owner);
7216 return nativeResponseValue;
7218 // struct LDKDecodeError CResult_ClaimedHTLCDecodeErrorZ_get_err(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR owner);
7220 export function CResult_ClaimedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
7221 if(!isWasmInitialized) {
7222 throw new Error("initializeWasm() must be awaited first!");
7224 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_get_err(owner);
7225 return nativeResponseValue;
7228 export class LDKPathFailure {
7229 protected constructor() {}
7232 export function LDKPathFailure_ty_from_ptr(ptr: bigint): number {
7233 if(!isWasmInitialized) {
7234 throw new Error("initializeWasm() must be awaited first!");
7236 const nativeResponseValue = wasm.TS_LDKPathFailure_ty_from_ptr(ptr);
7237 return nativeResponseValue;
7240 export function LDKPathFailure_InitialSend_get_err(ptr: bigint): bigint {
7241 if(!isWasmInitialized) {
7242 throw new Error("initializeWasm() must be awaited first!");
7244 const nativeResponseValue = wasm.TS_LDKPathFailure_InitialSend_get_err(ptr);
7245 return nativeResponseValue;
7248 export function LDKPathFailure_OnPath_get_network_update(ptr: bigint): bigint {
7249 if(!isWasmInitialized) {
7250 throw new Error("initializeWasm() must be awaited first!");
7252 const nativeResponseValue = wasm.TS_LDKPathFailure_OnPath_get_network_update(ptr);
7253 return nativeResponseValue;
7256 export class LDKCOption_PathFailureZ {
7257 protected constructor() {}
7260 export function LDKCOption_PathFailureZ_ty_from_ptr(ptr: bigint): number {
7261 if(!isWasmInitialized) {
7262 throw new Error("initializeWasm() must be awaited first!");
7264 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_ty_from_ptr(ptr);
7265 return nativeResponseValue;
7268 export function LDKCOption_PathFailureZ_Some_get_some(ptr: bigint): bigint {
7269 if(!isWasmInitialized) {
7270 throw new Error("initializeWasm() must be awaited first!");
7272 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_Some_get_some(ptr);
7273 return nativeResponseValue;
7275 // struct LDKCOption_PathFailureZ CResult_COption_PathFailureZDecodeErrorZ_get_ok(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
7277 export function CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner: bigint): bigint {
7278 if(!isWasmInitialized) {
7279 throw new Error("initializeWasm() must be awaited first!");
7281 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner);
7282 return nativeResponseValue;
7284 // struct LDKDecodeError CResult_COption_PathFailureZDecodeErrorZ_get_err(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
7286 export function CResult_COption_PathFailureZDecodeErrorZ_get_err(owner: bigint): bigint {
7287 if(!isWasmInitialized) {
7288 throw new Error("initializeWasm() must be awaited first!");
7290 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_err(owner);
7291 return nativeResponseValue;
7294 export class LDKClosureReason {
7295 protected constructor() {}
7298 export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
7299 if(!isWasmInitialized) {
7300 throw new Error("initializeWasm() must be awaited first!");
7302 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
7303 return nativeResponseValue;
7306 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): bigint {
7307 if(!isWasmInitialized) {
7308 throw new Error("initializeWasm() must be awaited first!");
7310 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
7311 return nativeResponseValue;
7314 export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
7315 if(!isWasmInitialized) {
7316 throw new Error("initializeWasm() must be awaited first!");
7318 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
7319 return nativeResponseValue;
7322 export class LDKCOption_ClosureReasonZ {
7323 protected constructor() {}
7326 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
7327 if(!isWasmInitialized) {
7328 throw new Error("initializeWasm() must be awaited first!");
7330 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
7331 return nativeResponseValue;
7334 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
7335 if(!isWasmInitialized) {
7336 throw new Error("initializeWasm() must be awaited first!");
7338 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
7339 return nativeResponseValue;
7341 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
7343 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
7344 if(!isWasmInitialized) {
7345 throw new Error("initializeWasm() must be awaited first!");
7347 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
7348 return nativeResponseValue;
7350 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
7352 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
7353 if(!isWasmInitialized) {
7354 throw new Error("initializeWasm() must be awaited first!");
7356 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
7357 return nativeResponseValue;
7360 export class LDKHTLCDestination {
7361 protected constructor() {}
7364 export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
7365 if(!isWasmInitialized) {
7366 throw new Error("initializeWasm() must be awaited first!");
7368 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
7369 return nativeResponseValue;
7372 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
7373 if(!isWasmInitialized) {
7374 throw new Error("initializeWasm() must be awaited first!");
7376 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
7377 return nativeResponseValue;
7380 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): number {
7381 if(!isWasmInitialized) {
7382 throw new Error("initializeWasm() must be awaited first!");
7384 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
7385 return nativeResponseValue;
7388 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
7389 if(!isWasmInitialized) {
7390 throw new Error("initializeWasm() must be awaited first!");
7392 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
7393 return nativeResponseValue;
7396 export function LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr: bigint): bigint {
7397 if(!isWasmInitialized) {
7398 throw new Error("initializeWasm() must be awaited first!");
7400 const nativeResponseValue = wasm.TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr);
7401 return nativeResponseValue;
7404 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
7405 if(!isWasmInitialized) {
7406 throw new Error("initializeWasm() must be awaited first!");
7408 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
7409 return nativeResponseValue;
7412 export class LDKCOption_HTLCDestinationZ {
7413 protected constructor() {}
7416 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
7417 if(!isWasmInitialized) {
7418 throw new Error("initializeWasm() must be awaited first!");
7420 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
7421 return nativeResponseValue;
7424 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
7425 if(!isWasmInitialized) {
7426 throw new Error("initializeWasm() must be awaited first!");
7428 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
7429 return nativeResponseValue;
7431 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
7433 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
7434 if(!isWasmInitialized) {
7435 throw new Error("initializeWasm() must be awaited first!");
7437 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
7438 return nativeResponseValue;
7440 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
7442 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
7443 if(!isWasmInitialized) {
7444 throw new Error("initializeWasm() must be awaited first!");
7446 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
7447 return nativeResponseValue;
7449 // enum LDKPaymentFailureReason CResult_PaymentFailureReasonDecodeErrorZ_get_ok(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
7451 export function CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner: bigint): PaymentFailureReason {
7452 if(!isWasmInitialized) {
7453 throw new Error("initializeWasm() must be awaited first!");
7455 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner);
7456 return nativeResponseValue;
7458 // struct LDKDecodeError CResult_PaymentFailureReasonDecodeErrorZ_get_err(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
7460 export function CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner: bigint): bigint {
7461 if(!isWasmInitialized) {
7462 throw new Error("initializeWasm() must be awaited first!");
7464 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner);
7465 return nativeResponseValue;
7468 export class LDKCOption_U128Z {
7469 protected constructor() {}
7472 export function LDKCOption_U128Z_ty_from_ptr(ptr: bigint): number {
7473 if(!isWasmInitialized) {
7474 throw new Error("initializeWasm() must be awaited first!");
7476 const nativeResponseValue = wasm.TS_LDKCOption_U128Z_ty_from_ptr(ptr);
7477 return nativeResponseValue;
7480 export function LDKCOption_U128Z_Some_get_some(ptr: bigint): number {
7481 if(!isWasmInitialized) {
7482 throw new Error("initializeWasm() must be awaited first!");
7484 const nativeResponseValue = wasm.TS_LDKCOption_U128Z_Some_get_some(ptr);
7485 return nativeResponseValue;
7488 export class LDKCOption_PaymentFailureReasonZ {
7489 protected constructor() {}
7492 export function LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr: bigint): number {
7493 if(!isWasmInitialized) {
7494 throw new Error("initializeWasm() must be awaited first!");
7496 const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr);
7497 return nativeResponseValue;
7500 export function LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr: bigint): PaymentFailureReason {
7501 if(!isWasmInitialized) {
7502 throw new Error("initializeWasm() must be awaited first!");
7504 const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr);
7505 return nativeResponseValue;
7508 export class LDKBumpTransactionEvent {
7509 protected constructor() {}
7512 export function LDKBumpTransactionEvent_ty_from_ptr(ptr: bigint): number {
7513 if(!isWasmInitialized) {
7514 throw new Error("initializeWasm() must be awaited first!");
7516 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ty_from_ptr(ptr);
7517 return nativeResponseValue;
7520 export function LDKBumpTransactionEvent_ChannelClose_get_claim_id(ptr: bigint): number {
7521 if(!isWasmInitialized) {
7522 throw new Error("initializeWasm() must be awaited first!");
7524 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_claim_id(ptr);
7525 return nativeResponseValue;
7528 export function LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(ptr: bigint): number {
7529 if(!isWasmInitialized) {
7530 throw new Error("initializeWasm() must be awaited first!");
7532 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(ptr);
7533 return nativeResponseValue;
7536 export function LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(ptr: bigint): number {
7537 if(!isWasmInitialized) {
7538 throw new Error("initializeWasm() must be awaited first!");
7540 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(ptr);
7541 return nativeResponseValue;
7544 export function LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(ptr: bigint): bigint {
7545 if(!isWasmInitialized) {
7546 throw new Error("initializeWasm() must be awaited first!");
7548 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(ptr);
7549 return nativeResponseValue;
7552 export function LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(ptr: bigint): bigint {
7553 if(!isWasmInitialized) {
7554 throw new Error("initializeWasm() must be awaited first!");
7556 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(ptr);
7557 return nativeResponseValue;
7560 export function LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(ptr: bigint): number {
7561 if(!isWasmInitialized) {
7562 throw new Error("initializeWasm() must be awaited first!");
7564 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(ptr);
7565 return nativeResponseValue;
7568 export function LDKBumpTransactionEvent_HTLCResolution_get_claim_id(ptr: bigint): number {
7569 if(!isWasmInitialized) {
7570 throw new Error("initializeWasm() must be awaited first!");
7572 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_claim_id(ptr);
7573 return nativeResponseValue;
7576 export function LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(ptr: bigint): number {
7577 if(!isWasmInitialized) {
7578 throw new Error("initializeWasm() must be awaited first!");
7580 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(ptr);
7581 return nativeResponseValue;
7584 export function LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(ptr: bigint): number {
7585 if(!isWasmInitialized) {
7586 throw new Error("initializeWasm() must be awaited first!");
7588 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(ptr);
7589 return nativeResponseValue;
7592 export function LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(ptr: bigint): number {
7593 if(!isWasmInitialized) {
7594 throw new Error("initializeWasm() must be awaited first!");
7596 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(ptr);
7597 return nativeResponseValue;
7600 export class LDKEvent {
7601 protected constructor() {}
7604 export function LDKEvent_ty_from_ptr(ptr: bigint): number {
7605 if(!isWasmInitialized) {
7606 throw new Error("initializeWasm() must be awaited first!");
7608 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
7609 return nativeResponseValue;
7612 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): number {
7613 if(!isWasmInitialized) {
7614 throw new Error("initializeWasm() must be awaited first!");
7616 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
7617 return nativeResponseValue;
7620 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
7621 if(!isWasmInitialized) {
7622 throw new Error("initializeWasm() must be awaited first!");
7624 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
7625 return nativeResponseValue;
7628 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
7629 if(!isWasmInitialized) {
7630 throw new Error("initializeWasm() must be awaited first!");
7632 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
7633 return nativeResponseValue;
7636 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
7637 if(!isWasmInitialized) {
7638 throw new Error("initializeWasm() must be awaited first!");
7640 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
7641 return nativeResponseValue;
7644 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): number {
7645 if(!isWasmInitialized) {
7646 throw new Error("initializeWasm() must be awaited first!");
7648 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
7649 return nativeResponseValue;
7652 export function LDKEvent_PaymentClaimable_get_receiver_node_id(ptr: bigint): number {
7653 if(!isWasmInitialized) {
7654 throw new Error("initializeWasm() must be awaited first!");
7656 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_receiver_node_id(ptr);
7657 return nativeResponseValue;
7660 export function LDKEvent_PaymentClaimable_get_payment_hash(ptr: bigint): number {
7661 if(!isWasmInitialized) {
7662 throw new Error("initializeWasm() must be awaited first!");
7664 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_payment_hash(ptr);
7665 return nativeResponseValue;
7668 export function LDKEvent_PaymentClaimable_get_onion_fields(ptr: bigint): bigint {
7669 if(!isWasmInitialized) {
7670 throw new Error("initializeWasm() must be awaited first!");
7672 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_onion_fields(ptr);
7673 return nativeResponseValue;
7676 export function LDKEvent_PaymentClaimable_get_amount_msat(ptr: bigint): bigint {
7677 if(!isWasmInitialized) {
7678 throw new Error("initializeWasm() must be awaited first!");
7680 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_amount_msat(ptr);
7681 return nativeResponseValue;
7684 export function LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat(ptr: bigint): bigint {
7685 if(!isWasmInitialized) {
7686 throw new Error("initializeWasm() must be awaited first!");
7688 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat(ptr);
7689 return nativeResponseValue;
7692 export function LDKEvent_PaymentClaimable_get_purpose(ptr: bigint): bigint {
7693 if(!isWasmInitialized) {
7694 throw new Error("initializeWasm() must be awaited first!");
7696 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_purpose(ptr);
7697 return nativeResponseValue;
7700 export function LDKEvent_PaymentClaimable_get_via_channel_id(ptr: bigint): bigint {
7701 if(!isWasmInitialized) {
7702 throw new Error("initializeWasm() must be awaited first!");
7704 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_channel_id(ptr);
7705 return nativeResponseValue;
7708 export function LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr: bigint): bigint {
7709 if(!isWasmInitialized) {
7710 throw new Error("initializeWasm() must be awaited first!");
7712 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr);
7713 return nativeResponseValue;
7716 export function LDKEvent_PaymentClaimable_get_claim_deadline(ptr: bigint): bigint {
7717 if(!isWasmInitialized) {
7718 throw new Error("initializeWasm() must be awaited first!");
7720 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_claim_deadline(ptr);
7721 return nativeResponseValue;
7724 export function LDKEvent_PaymentClaimed_get_receiver_node_id(ptr: bigint): number {
7725 if(!isWasmInitialized) {
7726 throw new Error("initializeWasm() must be awaited first!");
7728 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_receiver_node_id(ptr);
7729 return nativeResponseValue;
7732 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: bigint): number {
7733 if(!isWasmInitialized) {
7734 throw new Error("initializeWasm() must be awaited first!");
7736 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
7737 return nativeResponseValue;
7740 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: bigint): bigint {
7741 if(!isWasmInitialized) {
7742 throw new Error("initializeWasm() must be awaited first!");
7744 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
7745 return nativeResponseValue;
7748 export function LDKEvent_PaymentClaimed_get_purpose(ptr: bigint): bigint {
7749 if(!isWasmInitialized) {
7750 throw new Error("initializeWasm() must be awaited first!");
7752 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
7753 return nativeResponseValue;
7756 export function LDKEvent_PaymentClaimed_get_htlcs(ptr: bigint): number {
7757 if(!isWasmInitialized) {
7758 throw new Error("initializeWasm() must be awaited first!");
7760 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_htlcs(ptr);
7761 return nativeResponseValue;
7764 export function LDKEvent_PaymentClaimed_get_sender_intended_total_msat(ptr: bigint): bigint {
7765 if(!isWasmInitialized) {
7766 throw new Error("initializeWasm() must be awaited first!");
7768 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_sender_intended_total_msat(ptr);
7769 return nativeResponseValue;
7772 export function LDKEvent_InvoiceRequestFailed_get_payment_id(ptr: bigint): number {
7773 if(!isWasmInitialized) {
7774 throw new Error("initializeWasm() must be awaited first!");
7776 const nativeResponseValue = wasm.TS_LDKEvent_InvoiceRequestFailed_get_payment_id(ptr);
7777 return nativeResponseValue;
7780 export function LDKEvent_PaymentSent_get_payment_id(ptr: bigint): bigint {
7781 if(!isWasmInitialized) {
7782 throw new Error("initializeWasm() must be awaited first!");
7784 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
7785 return nativeResponseValue;
7788 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: bigint): number {
7789 if(!isWasmInitialized) {
7790 throw new Error("initializeWasm() must be awaited first!");
7792 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
7793 return nativeResponseValue;
7796 export function LDKEvent_PaymentSent_get_payment_hash(ptr: bigint): number {
7797 if(!isWasmInitialized) {
7798 throw new Error("initializeWasm() must be awaited first!");
7800 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
7801 return nativeResponseValue;
7804 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: bigint): bigint {
7805 if(!isWasmInitialized) {
7806 throw new Error("initializeWasm() must be awaited first!");
7808 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
7809 return nativeResponseValue;
7812 export function LDKEvent_PaymentFailed_get_payment_id(ptr: bigint): number {
7813 if(!isWasmInitialized) {
7814 throw new Error("initializeWasm() must be awaited first!");
7816 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
7817 return nativeResponseValue;
7820 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: bigint): number {
7821 if(!isWasmInitialized) {
7822 throw new Error("initializeWasm() must be awaited first!");
7824 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
7825 return nativeResponseValue;
7828 export function LDKEvent_PaymentFailed_get_reason(ptr: bigint): bigint {
7829 if(!isWasmInitialized) {
7830 throw new Error("initializeWasm() must be awaited first!");
7832 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_reason(ptr);
7833 return nativeResponseValue;
7836 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: bigint): number {
7837 if(!isWasmInitialized) {
7838 throw new Error("initializeWasm() must be awaited first!");
7840 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
7841 return nativeResponseValue;
7844 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: bigint): bigint {
7845 if(!isWasmInitialized) {
7846 throw new Error("initializeWasm() must be awaited first!");
7848 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
7849 return nativeResponseValue;
7852 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): bigint {
7853 if(!isWasmInitialized) {
7854 throw new Error("initializeWasm() must be awaited first!");
7856 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
7857 return nativeResponseValue;
7860 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: bigint): bigint {
7861 if(!isWasmInitialized) {
7862 throw new Error("initializeWasm() must be awaited first!");
7864 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
7865 return nativeResponseValue;
7868 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: bigint): number {
7869 if(!isWasmInitialized) {
7870 throw new Error("initializeWasm() must be awaited first!");
7872 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
7873 return nativeResponseValue;
7876 export function LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr: bigint): boolean {
7877 if(!isWasmInitialized) {
7878 throw new Error("initializeWasm() must be awaited first!");
7880 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr);
7881 return nativeResponseValue;
7884 export function LDKEvent_PaymentPathFailed_get_failure(ptr: bigint): bigint {
7885 if(!isWasmInitialized) {
7886 throw new Error("initializeWasm() must be awaited first!");
7888 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_failure(ptr);
7889 return nativeResponseValue;
7892 export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): bigint {
7893 if(!isWasmInitialized) {
7894 throw new Error("initializeWasm() must be awaited first!");
7896 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
7897 return nativeResponseValue;
7900 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: bigint): bigint {
7901 if(!isWasmInitialized) {
7902 throw new Error("initializeWasm() must be awaited first!");
7904 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
7905 return nativeResponseValue;
7908 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: bigint): number {
7909 if(!isWasmInitialized) {
7910 throw new Error("initializeWasm() must be awaited first!");
7912 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
7913 return nativeResponseValue;
7916 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: bigint): number {
7917 if(!isWasmInitialized) {
7918 throw new Error("initializeWasm() must be awaited first!");
7920 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
7921 return nativeResponseValue;
7924 export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): bigint {
7925 if(!isWasmInitialized) {
7926 throw new Error("initializeWasm() must be awaited first!");
7928 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
7929 return nativeResponseValue;
7932 export function LDKEvent_ProbeFailed_get_payment_id(ptr: bigint): number {
7933 if(!isWasmInitialized) {
7934 throw new Error("initializeWasm() must be awaited first!");
7936 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
7937 return nativeResponseValue;
7940 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: bigint): number {
7941 if(!isWasmInitialized) {
7942 throw new Error("initializeWasm() must be awaited first!");
7944 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
7945 return nativeResponseValue;
7948 export function LDKEvent_ProbeFailed_get_path(ptr: bigint): bigint {
7949 if(!isWasmInitialized) {
7950 throw new Error("initializeWasm() must be awaited first!");
7952 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
7953 return nativeResponseValue;
7956 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: bigint): bigint {
7957 if(!isWasmInitialized) {
7958 throw new Error("initializeWasm() must be awaited first!");
7960 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
7961 return nativeResponseValue;
7964 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: bigint): bigint {
7965 if(!isWasmInitialized) {
7966 throw new Error("initializeWasm() must be awaited first!");
7968 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
7969 return nativeResponseValue;
7972 export function LDKEvent_HTLCIntercepted_get_intercept_id(ptr: bigint): number {
7973 if(!isWasmInitialized) {
7974 throw new Error("initializeWasm() must be awaited first!");
7976 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_intercept_id(ptr);
7977 return nativeResponseValue;
7980 export function LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr: bigint): bigint {
7981 if(!isWasmInitialized) {
7982 throw new Error("initializeWasm() must be awaited first!");
7984 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr);
7985 return nativeResponseValue;
7988 export function LDKEvent_HTLCIntercepted_get_payment_hash(ptr: bigint): number {
7989 if(!isWasmInitialized) {
7990 throw new Error("initializeWasm() must be awaited first!");
7992 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_payment_hash(ptr);
7993 return nativeResponseValue;
7996 export function LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr: bigint): bigint {
7997 if(!isWasmInitialized) {
7998 throw new Error("initializeWasm() must be awaited first!");
8000 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr);
8001 return nativeResponseValue;
8004 export function LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr: bigint): bigint {
8005 if(!isWasmInitialized) {
8006 throw new Error("initializeWasm() must be awaited first!");
8008 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr);
8009 return nativeResponseValue;
8012 export function LDKEvent_SpendableOutputs_get_outputs(ptr: bigint): number {
8013 if(!isWasmInitialized) {
8014 throw new Error("initializeWasm() must be awaited first!");
8016 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
8017 return nativeResponseValue;
8020 export function LDKEvent_SpendableOutputs_get_channel_id(ptr: bigint): bigint {
8021 if(!isWasmInitialized) {
8022 throw new Error("initializeWasm() must be awaited first!");
8024 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_channel_id(ptr);
8025 return nativeResponseValue;
8028 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: bigint): bigint {
8029 if(!isWasmInitialized) {
8030 throw new Error("initializeWasm() must be awaited first!");
8032 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
8033 return nativeResponseValue;
8036 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: bigint): bigint {
8037 if(!isWasmInitialized) {
8038 throw new Error("initializeWasm() must be awaited first!");
8040 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
8041 return nativeResponseValue;
8044 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: bigint): bigint {
8045 if(!isWasmInitialized) {
8046 throw new Error("initializeWasm() must be awaited first!");
8048 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
8049 return nativeResponseValue;
8052 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: bigint): boolean {
8053 if(!isWasmInitialized) {
8054 throw new Error("initializeWasm() must be awaited first!");
8056 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
8057 return nativeResponseValue;
8060 export function LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr: bigint): bigint {
8061 if(!isWasmInitialized) {
8062 throw new Error("initializeWasm() must be awaited first!");
8064 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr);
8065 return nativeResponseValue;
8068 export function LDKEvent_ChannelPending_get_channel_id(ptr: bigint): number {
8069 if(!isWasmInitialized) {
8070 throw new Error("initializeWasm() must be awaited first!");
8072 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_channel_id(ptr);
8073 return nativeResponseValue;
8076 export function LDKEvent_ChannelPending_get_user_channel_id(ptr: bigint): number {
8077 if(!isWasmInitialized) {
8078 throw new Error("initializeWasm() must be awaited first!");
8080 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_user_channel_id(ptr);
8081 return nativeResponseValue;
8084 export function LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr: bigint): bigint {
8085 if(!isWasmInitialized) {
8086 throw new Error("initializeWasm() must be awaited first!");
8088 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr);
8089 return nativeResponseValue;
8092 export function LDKEvent_ChannelPending_get_counterparty_node_id(ptr: bigint): number {
8093 if(!isWasmInitialized) {
8094 throw new Error("initializeWasm() must be awaited first!");
8096 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_counterparty_node_id(ptr);
8097 return nativeResponseValue;
8100 export function LDKEvent_ChannelPending_get_funding_txo(ptr: bigint): bigint {
8101 if(!isWasmInitialized) {
8102 throw new Error("initializeWasm() must be awaited first!");
8104 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_funding_txo(ptr);
8105 return nativeResponseValue;
8108 export function LDKEvent_ChannelReady_get_channel_id(ptr: bigint): number {
8109 if(!isWasmInitialized) {
8110 throw new Error("initializeWasm() must be awaited first!");
8112 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_id(ptr);
8113 return nativeResponseValue;
8116 export function LDKEvent_ChannelReady_get_user_channel_id(ptr: bigint): number {
8117 if(!isWasmInitialized) {
8118 throw new Error("initializeWasm() must be awaited first!");
8120 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_user_channel_id(ptr);
8121 return nativeResponseValue;
8124 export function LDKEvent_ChannelReady_get_counterparty_node_id(ptr: bigint): number {
8125 if(!isWasmInitialized) {
8126 throw new Error("initializeWasm() must be awaited first!");
8128 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_counterparty_node_id(ptr);
8129 return nativeResponseValue;
8132 export function LDKEvent_ChannelReady_get_channel_type(ptr: bigint): bigint {
8133 if(!isWasmInitialized) {
8134 throw new Error("initializeWasm() must be awaited first!");
8136 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_type(ptr);
8137 return nativeResponseValue;
8140 export function LDKEvent_ChannelClosed_get_channel_id(ptr: bigint): number {
8141 if(!isWasmInitialized) {
8142 throw new Error("initializeWasm() must be awaited first!");
8144 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
8145 return nativeResponseValue;
8148 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: bigint): number {
8149 if(!isWasmInitialized) {
8150 throw new Error("initializeWasm() must be awaited first!");
8152 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
8153 return nativeResponseValue;
8156 export function LDKEvent_ChannelClosed_get_reason(ptr: bigint): bigint {
8157 if(!isWasmInitialized) {
8158 throw new Error("initializeWasm() must be awaited first!");
8160 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
8161 return nativeResponseValue;
8164 export function LDKEvent_ChannelClosed_get_counterparty_node_id(ptr: bigint): number {
8165 if(!isWasmInitialized) {
8166 throw new Error("initializeWasm() must be awaited first!");
8168 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_counterparty_node_id(ptr);
8169 return nativeResponseValue;
8172 export function LDKEvent_ChannelClosed_get_channel_capacity_sats(ptr: bigint): bigint {
8173 if(!isWasmInitialized) {
8174 throw new Error("initializeWasm() must be awaited first!");
8176 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_capacity_sats(ptr);
8177 return nativeResponseValue;
8180 export function LDKEvent_DiscardFunding_get_channel_id(ptr: bigint): number {
8181 if(!isWasmInitialized) {
8182 throw new Error("initializeWasm() must be awaited first!");
8184 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
8185 return nativeResponseValue;
8188 export function LDKEvent_DiscardFunding_get_transaction(ptr: bigint): number {
8189 if(!isWasmInitialized) {
8190 throw new Error("initializeWasm() must be awaited first!");
8192 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
8193 return nativeResponseValue;
8196 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: bigint): number {
8197 if(!isWasmInitialized) {
8198 throw new Error("initializeWasm() must be awaited first!");
8200 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
8201 return nativeResponseValue;
8204 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: bigint): number {
8205 if(!isWasmInitialized) {
8206 throw new Error("initializeWasm() must be awaited first!");
8208 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
8209 return nativeResponseValue;
8212 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: bigint): bigint {
8213 if(!isWasmInitialized) {
8214 throw new Error("initializeWasm() must be awaited first!");
8216 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
8217 return nativeResponseValue;
8220 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: bigint): bigint {
8221 if(!isWasmInitialized) {
8222 throw new Error("initializeWasm() must be awaited first!");
8224 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
8225 return nativeResponseValue;
8228 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: bigint): bigint {
8229 if(!isWasmInitialized) {
8230 throw new Error("initializeWasm() must be awaited first!");
8232 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
8233 return nativeResponseValue;
8236 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: bigint): number {
8237 if(!isWasmInitialized) {
8238 throw new Error("initializeWasm() must be awaited first!");
8240 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
8241 return nativeResponseValue;
8244 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: bigint): bigint {
8245 if(!isWasmInitialized) {
8246 throw new Error("initializeWasm() must be awaited first!");
8248 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
8249 return nativeResponseValue;
8252 export function LDKEvent_BumpTransaction_get_bump_transaction(ptr: bigint): bigint {
8253 if(!isWasmInitialized) {
8254 throw new Error("initializeWasm() must be awaited first!");
8256 const nativeResponseValue = wasm.TS_LDKEvent_BumpTransaction_get_bump_transaction(ptr);
8257 return nativeResponseValue;
8260 export class LDKCOption_EventZ {
8261 protected constructor() {}
8264 export function LDKCOption_EventZ_ty_from_ptr(ptr: bigint): number {
8265 if(!isWasmInitialized) {
8266 throw new Error("initializeWasm() must be awaited first!");
8268 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
8269 return nativeResponseValue;
8272 export function LDKCOption_EventZ_Some_get_some(ptr: bigint): bigint {
8273 if(!isWasmInitialized) {
8274 throw new Error("initializeWasm() must be awaited first!");
8276 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
8277 return nativeResponseValue;
8279 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
8281 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: bigint): bigint {
8282 if(!isWasmInitialized) {
8283 throw new Error("initializeWasm() must be awaited first!");
8285 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
8286 return nativeResponseValue;
8288 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
8290 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: bigint): bigint {
8291 if(!isWasmInitialized) {
8292 throw new Error("initializeWasm() must be awaited first!");
8294 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
8295 return nativeResponseValue;
8298 export class LDKBolt11ParseError {
8299 protected constructor() {}
8302 export function LDKBolt11ParseError_ty_from_ptr(ptr: bigint): number {
8303 if(!isWasmInitialized) {
8304 throw new Error("initializeWasm() must be awaited first!");
8306 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_ty_from_ptr(ptr);
8307 return nativeResponseValue;
8310 export function LDKBolt11ParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
8311 if(!isWasmInitialized) {
8312 throw new Error("initializeWasm() must be awaited first!");
8314 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_Bech32Error_get_bech32_error(ptr);
8315 return nativeResponseValue;
8318 export function LDKBolt11ParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
8319 if(!isWasmInitialized) {
8320 throw new Error("initializeWasm() must be awaited first!");
8322 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_ParseAmountError_get_parse_amount_error(ptr);
8323 return nativeResponseValue;
8326 export function LDKBolt11ParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
8327 if(!isWasmInitialized) {
8328 throw new Error("initializeWasm() must be awaited first!");
8330 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_MalformedSignature_get_malformed_signature(ptr);
8331 return nativeResponseValue;
8334 export function LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
8335 if(!isWasmInitialized) {
8336 throw new Error("initializeWasm() must be awaited first!");
8338 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error(ptr);
8339 return nativeResponseValue;
8342 export function LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
8343 if(!isWasmInitialized) {
8344 throw new Error("initializeWasm() must be awaited first!");
8346 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
8347 return nativeResponseValue;
8349 // enum LDKSiPrefix CResult_SiPrefixBolt11ParseErrorZ_get_ok(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
8351 export function CResult_SiPrefixBolt11ParseErrorZ_get_ok(owner: bigint): SiPrefix {
8352 if(!isWasmInitialized) {
8353 throw new Error("initializeWasm() must be awaited first!");
8355 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_get_ok(owner);
8356 return nativeResponseValue;
8358 // struct LDKBolt11ParseError CResult_SiPrefixBolt11ParseErrorZ_get_err(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
8360 export function CResult_SiPrefixBolt11ParseErrorZ_get_err(owner: bigint): bigint {
8361 if(!isWasmInitialized) {
8362 throw new Error("initializeWasm() must be awaited first!");
8364 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_get_err(owner);
8365 return nativeResponseValue;
8368 export class LDKParseOrSemanticError {
8369 protected constructor() {}
8372 export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
8373 if(!isWasmInitialized) {
8374 throw new Error("initializeWasm() must be awaited first!");
8376 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
8377 return nativeResponseValue;
8380 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
8381 if(!isWasmInitialized) {
8382 throw new Error("initializeWasm() must be awaited first!");
8384 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
8385 return nativeResponseValue;
8388 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): Bolt11SemanticError {
8389 if(!isWasmInitialized) {
8390 throw new Error("initializeWasm() must be awaited first!");
8392 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
8393 return nativeResponseValue;
8395 // struct LDKBolt11Invoice CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
8397 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
8398 if(!isWasmInitialized) {
8399 throw new Error("initializeWasm() must be awaited first!");
8401 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(owner);
8402 return nativeResponseValue;
8404 // struct LDKParseOrSemanticError CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
8406 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
8407 if(!isWasmInitialized) {
8408 throw new Error("initializeWasm() must be awaited first!");
8410 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(owner);
8411 return nativeResponseValue;
8413 // struct LDKSignedRawBolt11Invoice CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
8415 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(owner: bigint): bigint {
8416 if(!isWasmInitialized) {
8417 throw new Error("initializeWasm() must be awaited first!");
8419 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(owner);
8420 return nativeResponseValue;
8422 // struct LDKBolt11ParseError CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
8424 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(owner: bigint): bigint {
8425 if(!isWasmInitialized) {
8426 throw new Error("initializeWasm() must be awaited first!");
8428 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(owner);
8429 return nativeResponseValue;
8431 // struct LDKRawBolt11Invoice C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8433 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(owner: bigint): bigint {
8434 if(!isWasmInitialized) {
8435 throw new Error("initializeWasm() must be awaited first!");
8437 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(owner);
8438 return nativeResponseValue;
8440 // struct LDKThirtyTwoBytes C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8442 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(owner: bigint): number {
8443 if(!isWasmInitialized) {
8444 throw new Error("initializeWasm() must be awaited first!");
8446 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(owner);
8447 return nativeResponseValue;
8449 // struct LDKBolt11InvoiceSignature C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8451 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(owner: bigint): bigint {
8452 if(!isWasmInitialized) {
8453 throw new Error("initializeWasm() must be awaited first!");
8455 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(owner);
8456 return nativeResponseValue;
8458 // struct LDKPayeePubKey CResult_PayeePubKeySecp256k1ErrorZ_get_ok(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner);
8460 export function CResult_PayeePubKeySecp256k1ErrorZ_get_ok(owner: bigint): bigint {
8461 if(!isWasmInitialized) {
8462 throw new Error("initializeWasm() must be awaited first!");
8464 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_get_ok(owner);
8465 return nativeResponseValue;
8467 // enum LDKSecp256k1Error CResult_PayeePubKeySecp256k1ErrorZ_get_err(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner);
8469 export function CResult_PayeePubKeySecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
8470 if(!isWasmInitialized) {
8471 throw new Error("initializeWasm() must be awaited first!");
8473 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_get_err(owner);
8474 return nativeResponseValue;
8476 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
8478 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
8479 if(!isWasmInitialized) {
8480 throw new Error("initializeWasm() must be awaited first!");
8482 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
8483 return nativeResponseValue;
8485 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
8487 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
8488 if(!isWasmInitialized) {
8489 throw new Error("initializeWasm() must be awaited first!");
8491 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
8492 return nativeResponseValue;
8494 // void CResult_NoneBolt11SemanticErrorZ_get_ok(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
8496 export function CResult_NoneBolt11SemanticErrorZ_get_ok(owner: bigint): void {
8497 if(!isWasmInitialized) {
8498 throw new Error("initializeWasm() must be awaited first!");
8500 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_get_ok(owner);
8501 // debug statements here
8503 // enum LDKBolt11SemanticError CResult_NoneBolt11SemanticErrorZ_get_err(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
8505 export function CResult_NoneBolt11SemanticErrorZ_get_err(owner: bigint): Bolt11SemanticError {
8506 if(!isWasmInitialized) {
8507 throw new Error("initializeWasm() must be awaited first!");
8509 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_get_err(owner);
8510 return nativeResponseValue;
8512 // struct LDKBolt11Invoice CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
8514 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(owner: bigint): bigint {
8515 if(!isWasmInitialized) {
8516 throw new Error("initializeWasm() must be awaited first!");
8518 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(owner);
8519 return nativeResponseValue;
8521 // enum LDKBolt11SemanticError CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
8523 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(owner: bigint): Bolt11SemanticError {
8524 if(!isWasmInitialized) {
8525 throw new Error("initializeWasm() must be awaited first!");
8527 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(owner);
8528 return nativeResponseValue;
8530 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
8532 export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
8533 if(!isWasmInitialized) {
8534 throw new Error("initializeWasm() must be awaited first!");
8536 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
8537 return nativeResponseValue;
8539 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
8541 export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
8542 if(!isWasmInitialized) {
8543 throw new Error("initializeWasm() must be awaited first!");
8545 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
8546 return nativeResponseValue;
8548 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
8550 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
8551 if(!isWasmInitialized) {
8552 throw new Error("initializeWasm() must be awaited first!");
8554 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
8555 return nativeResponseValue;
8557 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
8559 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
8560 if(!isWasmInitialized) {
8561 throw new Error("initializeWasm() must be awaited first!");
8563 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
8564 return nativeResponseValue;
8566 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
8568 export function CResult_OutPointDecodeErrorZ_get_ok(owner: bigint): bigint {
8569 if(!isWasmInitialized) {
8570 throw new Error("initializeWasm() must be awaited first!");
8572 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
8573 return nativeResponseValue;
8575 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
8577 export function CResult_OutPointDecodeErrorZ_get_err(owner: bigint): bigint {
8578 if(!isWasmInitialized) {
8579 throw new Error("initializeWasm() must be awaited first!");
8581 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
8582 return nativeResponseValue;
8584 // struct LDKBigSize CResult_BigSizeDecodeErrorZ_get_ok(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
8586 export function CResult_BigSizeDecodeErrorZ_get_ok(owner: bigint): bigint {
8587 if(!isWasmInitialized) {
8588 throw new Error("initializeWasm() must be awaited first!");
8590 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_get_ok(owner);
8591 return nativeResponseValue;
8593 // struct LDKDecodeError CResult_BigSizeDecodeErrorZ_get_err(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
8595 export function CResult_BigSizeDecodeErrorZ_get_err(owner: bigint): bigint {
8596 if(!isWasmInitialized) {
8597 throw new Error("initializeWasm() must be awaited first!");
8599 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_get_err(owner);
8600 return nativeResponseValue;
8602 // struct LDKHostname CResult_HostnameDecodeErrorZ_get_ok(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
8604 export function CResult_HostnameDecodeErrorZ_get_ok(owner: bigint): bigint {
8605 if(!isWasmInitialized) {
8606 throw new Error("initializeWasm() must be awaited first!");
8608 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_get_ok(owner);
8609 return nativeResponseValue;
8611 // struct LDKDecodeError CResult_HostnameDecodeErrorZ_get_err(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
8613 export function CResult_HostnameDecodeErrorZ_get_err(owner: bigint): bigint {
8614 if(!isWasmInitialized) {
8615 throw new Error("initializeWasm() must be awaited first!");
8617 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_get_err(owner);
8618 return nativeResponseValue;
8620 // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedNoneZ_get_ok(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
8622 export function CResult_TransactionU16LenLimitedNoneZ_get_ok(owner: bigint): bigint {
8623 if(!isWasmInitialized) {
8624 throw new Error("initializeWasm() must be awaited first!");
8626 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_get_ok(owner);
8627 return nativeResponseValue;
8629 // void CResult_TransactionU16LenLimitedNoneZ_get_err(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
8631 export function CResult_TransactionU16LenLimitedNoneZ_get_err(owner: bigint): void {
8632 if(!isWasmInitialized) {
8633 throw new Error("initializeWasm() must be awaited first!");
8635 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_get_err(owner);
8636 // debug statements here
8638 // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
8640 export function CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(owner: bigint): bigint {
8641 if(!isWasmInitialized) {
8642 throw new Error("initializeWasm() must be awaited first!");
8644 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(owner);
8645 return nativeResponseValue;
8647 // struct LDKDecodeError CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
8649 export function CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(owner: bigint): bigint {
8650 if(!isWasmInitialized) {
8651 throw new Error("initializeWasm() must be awaited first!");
8653 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(owner);
8654 return nativeResponseValue;
8656 // struct LDKUntrustedString CResult_UntrustedStringDecodeErrorZ_get_ok(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
8658 export function CResult_UntrustedStringDecodeErrorZ_get_ok(owner: bigint): bigint {
8659 if(!isWasmInitialized) {
8660 throw new Error("initializeWasm() must be awaited first!");
8662 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_ok(owner);
8663 return nativeResponseValue;
8665 // struct LDKDecodeError CResult_UntrustedStringDecodeErrorZ_get_err(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
8667 export function CResult_UntrustedStringDecodeErrorZ_get_err(owner: bigint): bigint {
8668 if(!isWasmInitialized) {
8669 throw new Error("initializeWasm() must be awaited first!");
8671 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_err(owner);
8672 return nativeResponseValue;
8674 // struct LDKReceiveTlvs CResult_ReceiveTlvsDecodeErrorZ_get_ok(LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR owner);
8676 export function CResult_ReceiveTlvsDecodeErrorZ_get_ok(owner: bigint): bigint {
8677 if(!isWasmInitialized) {
8678 throw new Error("initializeWasm() must be awaited first!");
8680 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_get_ok(owner);
8681 return nativeResponseValue;
8683 // struct LDKDecodeError CResult_ReceiveTlvsDecodeErrorZ_get_err(LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR owner);
8685 export function CResult_ReceiveTlvsDecodeErrorZ_get_err(owner: bigint): bigint {
8686 if(!isWasmInitialized) {
8687 throw new Error("initializeWasm() must be awaited first!");
8689 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_get_err(owner);
8690 return nativeResponseValue;
8692 // struct LDKPaymentRelay CResult_PaymentRelayDecodeErrorZ_get_ok(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner);
8694 export function CResult_PaymentRelayDecodeErrorZ_get_ok(owner: bigint): bigint {
8695 if(!isWasmInitialized) {
8696 throw new Error("initializeWasm() must be awaited first!");
8698 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_get_ok(owner);
8699 return nativeResponseValue;
8701 // struct LDKDecodeError CResult_PaymentRelayDecodeErrorZ_get_err(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner);
8703 export function CResult_PaymentRelayDecodeErrorZ_get_err(owner: bigint): bigint {
8704 if(!isWasmInitialized) {
8705 throw new Error("initializeWasm() must be awaited first!");
8707 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_get_err(owner);
8708 return nativeResponseValue;
8710 // struct LDKPaymentConstraints CResult_PaymentConstraintsDecodeErrorZ_get_ok(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner);
8712 export function CResult_PaymentConstraintsDecodeErrorZ_get_ok(owner: bigint): bigint {
8713 if(!isWasmInitialized) {
8714 throw new Error("initializeWasm() must be awaited first!");
8716 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_get_ok(owner);
8717 return nativeResponseValue;
8719 // struct LDKDecodeError CResult_PaymentConstraintsDecodeErrorZ_get_err(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner);
8721 export function CResult_PaymentConstraintsDecodeErrorZ_get_err(owner: bigint): bigint {
8722 if(!isWasmInitialized) {
8723 throw new Error("initializeWasm() must be awaited first!");
8725 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_get_err(owner);
8726 return nativeResponseValue;
8729 export class LDKPaymentError {
8730 protected constructor() {}
8733 export function LDKPaymentError_ty_from_ptr(ptr: bigint): number {
8734 if(!isWasmInitialized) {
8735 throw new Error("initializeWasm() must be awaited first!");
8737 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
8738 return nativeResponseValue;
8741 export function LDKPaymentError_Invoice_get_invoice(ptr: bigint): number {
8742 if(!isWasmInitialized) {
8743 throw new Error("initializeWasm() must be awaited first!");
8745 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
8746 return nativeResponseValue;
8749 export function LDKPaymentError_Sending_get_sending(ptr: bigint): RetryableSendFailure {
8750 if(!isWasmInitialized) {
8751 throw new Error("initializeWasm() must be awaited first!");
8753 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
8754 return nativeResponseValue;
8756 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesPaymentErrorZ_get_ok(LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR owner);
8758 export function CResult_ThirtyTwoBytesPaymentErrorZ_get_ok(owner: bigint): number {
8759 if(!isWasmInitialized) {
8760 throw new Error("initializeWasm() must be awaited first!");
8762 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_get_ok(owner);
8763 return nativeResponseValue;
8765 // struct LDKPaymentError CResult_ThirtyTwoBytesPaymentErrorZ_get_err(LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR owner);
8767 export function CResult_ThirtyTwoBytesPaymentErrorZ_get_err(owner: bigint): bigint {
8768 if(!isWasmInitialized) {
8769 throw new Error("initializeWasm() must be awaited first!");
8771 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_get_err(owner);
8772 return nativeResponseValue;
8774 // void CResult_NonePaymentErrorZ_get_ok(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner);
8776 export function CResult_NonePaymentErrorZ_get_ok(owner: bigint): void {
8777 if(!isWasmInitialized) {
8778 throw new Error("initializeWasm() must be awaited first!");
8780 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_get_ok(owner);
8781 // debug statements here
8783 // struct LDKPaymentError CResult_NonePaymentErrorZ_get_err(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner);
8785 export function CResult_NonePaymentErrorZ_get_err(owner: bigint): bigint {
8786 if(!isWasmInitialized) {
8787 throw new Error("initializeWasm() must be awaited first!");
8789 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_get_err(owner);
8790 return nativeResponseValue;
8793 export class LDKProbingError {
8794 protected constructor() {}
8797 export function LDKProbingError_ty_from_ptr(ptr: bigint): number {
8798 if(!isWasmInitialized) {
8799 throw new Error("initializeWasm() must be awaited first!");
8801 const nativeResponseValue = wasm.TS_LDKProbingError_ty_from_ptr(ptr);
8802 return nativeResponseValue;
8805 export function LDKProbingError_Invoice_get_invoice(ptr: bigint): number {
8806 if(!isWasmInitialized) {
8807 throw new Error("initializeWasm() must be awaited first!");
8809 const nativeResponseValue = wasm.TS_LDKProbingError_Invoice_get_invoice(ptr);
8810 return nativeResponseValue;
8813 export function LDKProbingError_Sending_get_sending(ptr: bigint): bigint {
8814 if(!isWasmInitialized) {
8815 throw new Error("initializeWasm() must be awaited first!");
8817 const nativeResponseValue = wasm.TS_LDKProbingError_Sending_get_sending(ptr);
8818 return nativeResponseValue;
8820 // struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR owner);
8822 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_ok(owner: bigint): number {
8823 if(!isWasmInitialized) {
8824 throw new Error("initializeWasm() must be awaited first!");
8826 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_ok(owner);
8827 return nativeResponseValue;
8829 // struct LDKProbingError CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR owner);
8831 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_err(owner: bigint): bigint {
8832 if(!isWasmInitialized) {
8833 throw new Error("initializeWasm() must be awaited first!");
8835 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_err(owner);
8836 return nativeResponseValue;
8838 // struct LDKStr CResult_StrSecp256k1ErrorZ_get_ok(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner);
8840 export function CResult_StrSecp256k1ErrorZ_get_ok(owner: bigint): number {
8841 if(!isWasmInitialized) {
8842 throw new Error("initializeWasm() must be awaited first!");
8844 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_get_ok(owner);
8845 return nativeResponseValue;
8847 // enum LDKSecp256k1Error CResult_StrSecp256k1ErrorZ_get_err(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner);
8849 export function CResult_StrSecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
8850 if(!isWasmInitialized) {
8851 throw new Error("initializeWasm() must be awaited first!");
8853 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_get_err(owner);
8854 return nativeResponseValue;
8856 // struct LDKOnionMessagePath CResult_OnionMessagePathNoneZ_get_ok(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner);
8858 export function CResult_OnionMessagePathNoneZ_get_ok(owner: bigint): bigint {
8859 if(!isWasmInitialized) {
8860 throw new Error("initializeWasm() must be awaited first!");
8862 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_get_ok(owner);
8863 return nativeResponseValue;
8865 // void CResult_OnionMessagePathNoneZ_get_err(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner);
8867 export function CResult_OnionMessagePathNoneZ_get_err(owner: bigint): void {
8868 if(!isWasmInitialized) {
8869 throw new Error("initializeWasm() must be awaited first!");
8871 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_get_err(owner);
8872 // debug statements here
8874 // struct LDKPublicKey C2Tuple_PublicKeyOnionMessageZ_get_a(LDKC2Tuple_PublicKeyOnionMessageZ *NONNULL_PTR owner);
8876 export function C2Tuple_PublicKeyOnionMessageZ_get_a(owner: bigint): number {
8877 if(!isWasmInitialized) {
8878 throw new Error("initializeWasm() must be awaited first!");
8880 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_get_a(owner);
8881 return nativeResponseValue;
8883 // struct LDKOnionMessage C2Tuple_PublicKeyOnionMessageZ_get_b(LDKC2Tuple_PublicKeyOnionMessageZ *NONNULL_PTR owner);
8885 export function C2Tuple_PublicKeyOnionMessageZ_get_b(owner: bigint): bigint {
8886 if(!isWasmInitialized) {
8887 throw new Error("initializeWasm() must be awaited first!");
8889 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_get_b(owner);
8890 return nativeResponseValue;
8893 export class LDKSendError {
8894 protected constructor() {}
8897 export function LDKSendError_ty_from_ptr(ptr: bigint): number {
8898 if(!isWasmInitialized) {
8899 throw new Error("initializeWasm() must be awaited first!");
8901 const nativeResponseValue = wasm.TS_LDKSendError_ty_from_ptr(ptr);
8902 return nativeResponseValue;
8905 export function LDKSendError_Secp256k1_get_secp256k1(ptr: bigint): Secp256k1Error {
8906 if(!isWasmInitialized) {
8907 throw new Error("initializeWasm() must be awaited first!");
8909 const nativeResponseValue = wasm.TS_LDKSendError_Secp256k1_get_secp256k1(ptr);
8910 return nativeResponseValue;
8912 // struct LDKC2Tuple_PublicKeyOnionMessageZ CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_ok(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ *NONNULL_PTR owner);
8914 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_ok(owner: bigint): bigint {
8915 if(!isWasmInitialized) {
8916 throw new Error("initializeWasm() must be awaited first!");
8918 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_ok(owner);
8919 return nativeResponseValue;
8921 // struct LDKSendError CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_err(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ *NONNULL_PTR owner);
8923 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_err(owner: bigint): bigint {
8924 if(!isWasmInitialized) {
8925 throw new Error("initializeWasm() must be awaited first!");
8927 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_err(owner);
8928 return nativeResponseValue;
8931 export class LDKParsedOnionMessageContents {
8932 protected constructor() {}
8935 export function LDKParsedOnionMessageContents_ty_from_ptr(ptr: bigint): number {
8936 if(!isWasmInitialized) {
8937 throw new Error("initializeWasm() must be awaited first!");
8939 const nativeResponseValue = wasm.TS_LDKParsedOnionMessageContents_ty_from_ptr(ptr);
8940 return nativeResponseValue;
8943 export function LDKParsedOnionMessageContents_Offers_get_offers(ptr: bigint): bigint {
8944 if(!isWasmInitialized) {
8945 throw new Error("initializeWasm() must be awaited first!");
8947 const nativeResponseValue = wasm.TS_LDKParsedOnionMessageContents_Offers_get_offers(ptr);
8948 return nativeResponseValue;
8951 export function LDKParsedOnionMessageContents_Custom_get_custom(ptr: bigint): bigint {
8952 if(!isWasmInitialized) {
8953 throw new Error("initializeWasm() must be awaited first!");
8955 const nativeResponseValue = wasm.TS_LDKParsedOnionMessageContents_Custom_get_custom(ptr);
8956 return nativeResponseValue;
8959 export class LDKPeeledOnion {
8960 protected constructor() {}
8963 export function LDKPeeledOnion_ty_from_ptr(ptr: bigint): number {
8964 if(!isWasmInitialized) {
8965 throw new Error("initializeWasm() must be awaited first!");
8967 const nativeResponseValue = wasm.TS_LDKPeeledOnion_ty_from_ptr(ptr);
8968 return nativeResponseValue;
8971 export function LDKPeeledOnion_Forward_get__0(ptr: bigint): number {
8972 if(!isWasmInitialized) {
8973 throw new Error("initializeWasm() must be awaited first!");
8975 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Forward_get__0(ptr);
8976 return nativeResponseValue;
8979 export function LDKPeeledOnion_Forward_get__1(ptr: bigint): bigint {
8980 if(!isWasmInitialized) {
8981 throw new Error("initializeWasm() must be awaited first!");
8983 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Forward_get__1(ptr);
8984 return nativeResponseValue;
8987 export function LDKPeeledOnion_Receive_get__0(ptr: bigint): bigint {
8988 if(!isWasmInitialized) {
8989 throw new Error("initializeWasm() must be awaited first!");
8991 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Receive_get__0(ptr);
8992 return nativeResponseValue;
8995 export function LDKPeeledOnion_Receive_get__1(ptr: bigint): number {
8996 if(!isWasmInitialized) {
8997 throw new Error("initializeWasm() must be awaited first!");
8999 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Receive_get__1(ptr);
9000 return nativeResponseValue;
9003 export function LDKPeeledOnion_Receive_get__2(ptr: bigint): bigint {
9004 if(!isWasmInitialized) {
9005 throw new Error("initializeWasm() must be awaited first!");
9007 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Receive_get__2(ptr);
9008 return nativeResponseValue;
9010 // struct LDKPeeledOnion CResult_PeeledOnionNoneZ_get_ok(LDKCResult_PeeledOnionNoneZ *NONNULL_PTR owner);
9012 export function CResult_PeeledOnionNoneZ_get_ok(owner: bigint): bigint {
9013 if(!isWasmInitialized) {
9014 throw new Error("initializeWasm() must be awaited first!");
9016 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_get_ok(owner);
9017 return nativeResponseValue;
9019 // void CResult_PeeledOnionNoneZ_get_err(LDKCResult_PeeledOnionNoneZ *NONNULL_PTR owner);
9021 export function CResult_PeeledOnionNoneZ_get_err(owner: bigint): void {
9022 if(!isWasmInitialized) {
9023 throw new Error("initializeWasm() must be awaited first!");
9025 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_get_err(owner);
9026 // debug statements here
9028 // void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
9030 export function CResult_NoneSendErrorZ_get_ok(owner: bigint): void {
9031 if(!isWasmInitialized) {
9032 throw new Error("initializeWasm() must be awaited first!");
9034 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_ok(owner);
9035 // debug statements here
9037 // struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner);
9039 export function CResult_NoneSendErrorZ_get_err(owner: bigint): bigint {
9040 if(!isWasmInitialized) {
9041 throw new Error("initializeWasm() must be awaited first!");
9043 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_get_err(owner);
9044 return nativeResponseValue;
9046 // struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
9048 export function CResult_BlindedPathNoneZ_get_ok(owner: bigint): bigint {
9049 if(!isWasmInitialized) {
9050 throw new Error("initializeWasm() must be awaited first!");
9052 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_ok(owner);
9053 return nativeResponseValue;
9055 // void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
9057 export function CResult_BlindedPathNoneZ_get_err(owner: bigint): void {
9058 if(!isWasmInitialized) {
9059 throw new Error("initializeWasm() must be awaited first!");
9061 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_err(owner);
9062 // debug statements here
9064 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner);
9066 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(owner: bigint): bigint {
9067 if(!isWasmInitialized) {
9068 throw new Error("initializeWasm() must be awaited first!");
9070 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(owner);
9071 return nativeResponseValue;
9073 // void CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner);
9075 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(owner: bigint): void {
9076 if(!isWasmInitialized) {
9077 throw new Error("initializeWasm() must be awaited first!");
9079 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(owner);
9080 // debug statements here
9082 // struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
9084 export function CResult_BlindedPathDecodeErrorZ_get_ok(owner: bigint): bigint {
9085 if(!isWasmInitialized) {
9086 throw new Error("initializeWasm() must be awaited first!");
9088 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_ok(owner);
9089 return nativeResponseValue;
9091 // struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
9093 export function CResult_BlindedPathDecodeErrorZ_get_err(owner: bigint): bigint {
9094 if(!isWasmInitialized) {
9095 throw new Error("initializeWasm() must be awaited first!");
9097 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_err(owner);
9098 return nativeResponseValue;
9100 // struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
9102 export function CResult_BlindedHopDecodeErrorZ_get_ok(owner: bigint): bigint {
9103 if(!isWasmInitialized) {
9104 throw new Error("initializeWasm() must be awaited first!");
9106 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_ok(owner);
9107 return nativeResponseValue;
9109 // struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
9111 export function CResult_BlindedHopDecodeErrorZ_get_err(owner: bigint): bigint {
9112 if(!isWasmInitialized) {
9113 throw new Error("initializeWasm() must be awaited first!");
9115 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_err(owner);
9116 return nativeResponseValue;
9118 // struct LDKInvoiceError CResult_InvoiceErrorDecodeErrorZ_get_ok(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
9120 export function CResult_InvoiceErrorDecodeErrorZ_get_ok(owner: bigint): bigint {
9121 if(!isWasmInitialized) {
9122 throw new Error("initializeWasm() must be awaited first!");
9124 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_get_ok(owner);
9125 return nativeResponseValue;
9127 // struct LDKDecodeError CResult_InvoiceErrorDecodeErrorZ_get_err(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
9129 export function CResult_InvoiceErrorDecodeErrorZ_get_err(owner: bigint): bigint {
9130 if(!isWasmInitialized) {
9131 throw new Error("initializeWasm() must be awaited first!");
9133 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_get_err(owner);
9134 return nativeResponseValue;
9137 export interface LDKFilter {
9138 register_tx (txid: number, script_pubkey: number): void;
9139 register_output (output: bigint): void;
9143 export function LDKFilter_new(impl: LDKFilter): [bigint, number] {
9144 if(!isWasmInitialized) {
9145 throw new Error("initializeWasm() must be awaited first!");
9147 var new_obj_idx = js_objs.length;
9148 for (var i = 0; i < js_objs.length; i++) {
9149 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9151 js_objs[i] = new WeakRef(impl);
9152 return [wasm.TS_LDKFilter_new(i), i];
9154 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
9156 export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
9157 if(!isWasmInitialized) {
9158 throw new Error("initializeWasm() must be awaited first!");
9160 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
9161 // debug statements here
9163 // void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
9165 export function Filter_register_output(this_arg: bigint, output: bigint): void {
9166 if(!isWasmInitialized) {
9167 throw new Error("initializeWasm() must be awaited first!");
9169 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
9170 // debug statements here
9173 export class LDKCOption_FilterZ {
9174 protected constructor() {}
9177 export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
9178 if(!isWasmInitialized) {
9179 throw new Error("initializeWasm() must be awaited first!");
9181 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
9182 return nativeResponseValue;
9185 export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
9186 if(!isWasmInitialized) {
9187 throw new Error("initializeWasm() must be awaited first!");
9189 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
9190 return nativeResponseValue;
9192 // struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
9194 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
9195 if(!isWasmInitialized) {
9196 throw new Error("initializeWasm() must be awaited first!");
9198 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
9199 return nativeResponseValue;
9201 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
9203 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
9204 if(!isWasmInitialized) {
9205 throw new Error("initializeWasm() must be awaited first!");
9207 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
9208 // debug statements here
9210 // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
9212 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner: bigint): bigint {
9213 if(!isWasmInitialized) {
9214 throw new Error("initializeWasm() must be awaited first!");
9216 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner);
9217 return nativeResponseValue;
9219 // struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
9221 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner: bigint): number {
9222 if(!isWasmInitialized) {
9223 throw new Error("initializeWasm() must be awaited first!");
9225 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner);
9226 return nativeResponseValue;
9229 export interface LDKKVStore {
9230 read (primary_namespace: number, secondary_namespace: number, key: number): bigint;
9231 write (primary_namespace: number, secondary_namespace: number, key: number, buf: number): bigint;
9232 remove (primary_namespace: number, secondary_namespace: number, key: number, lazy: boolean): bigint;
9233 list (primary_namespace: number, secondary_namespace: number): bigint;
9237 export function LDKKVStore_new(impl: LDKKVStore): [bigint, number] {
9238 if(!isWasmInitialized) {
9239 throw new Error("initializeWasm() must be awaited first!");
9241 var new_obj_idx = js_objs.length;
9242 for (var i = 0; i < js_objs.length; i++) {
9243 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9245 js_objs[i] = new WeakRef(impl);
9246 return [wasm.TS_LDKKVStore_new(i), i];
9248 // LDKCResult_CVec_u8ZIOErrorZ KVStore_read LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key
9250 export function KVStore_read(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number): bigint {
9251 if(!isWasmInitialized) {
9252 throw new Error("initializeWasm() must be awaited first!");
9254 const nativeResponseValue = wasm.TS_KVStore_read(this_arg, primary_namespace, secondary_namespace, key);
9255 return nativeResponseValue;
9257 // LDKCResult_NoneIOErrorZ KVStore_write LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf
9259 export function KVStore_write(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number, buf: number): bigint {
9260 if(!isWasmInitialized) {
9261 throw new Error("initializeWasm() must be awaited first!");
9263 const nativeResponseValue = wasm.TS_KVStore_write(this_arg, primary_namespace, secondary_namespace, key, buf);
9264 return nativeResponseValue;
9266 // LDKCResult_NoneIOErrorZ KVStore_remove LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy
9268 export function KVStore_remove(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number, lazy: boolean): bigint {
9269 if(!isWasmInitialized) {
9270 throw new Error("initializeWasm() must be awaited first!");
9272 const nativeResponseValue = wasm.TS_KVStore_remove(this_arg, primary_namespace, secondary_namespace, key, lazy);
9273 return nativeResponseValue;
9275 // LDKCResult_CVec_StrZIOErrorZ KVStore_list LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace
9277 export function KVStore_list(this_arg: bigint, primary_namespace: number, secondary_namespace: number): bigint {
9278 if(!isWasmInitialized) {
9279 throw new Error("initializeWasm() must be awaited first!");
9281 const nativeResponseValue = wasm.TS_KVStore_list(this_arg, primary_namespace, secondary_namespace);
9282 return nativeResponseValue;
9285 export interface LDKScoreLookUp {
9286 channel_penalty_msat (short_channel_id: bigint, source: bigint, target: bigint, usage: bigint, score_params: bigint): bigint;
9290 export function LDKScoreLookUp_new(impl: LDKScoreLookUp): [bigint, number] {
9291 if(!isWasmInitialized) {
9292 throw new Error("initializeWasm() must be awaited first!");
9294 var new_obj_idx = js_objs.length;
9295 for (var i = 0; i < js_objs.length; i++) {
9296 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9298 js_objs[i] = new WeakRef(impl);
9299 return [wasm.TS_LDKScoreLookUp_new(i), i];
9301 // uint64_t ScoreLookUp_channel_penalty_msat LDKScoreLookUp *NONNULL_PTR this_arg, uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params
9303 export function ScoreLookUp_channel_penalty_msat(this_arg: bigint, short_channel_id: bigint, source: bigint, target: bigint, usage: bigint, score_params: bigint): bigint {
9304 if(!isWasmInitialized) {
9305 throw new Error("initializeWasm() must be awaited first!");
9307 const nativeResponseValue = wasm.TS_ScoreLookUp_channel_penalty_msat(this_arg, short_channel_id, source, target, usage, score_params);
9308 return nativeResponseValue;
9311 export interface LDKScoreUpdate {
9312 payment_path_failed (path: bigint, short_channel_id: bigint): void;
9313 payment_path_successful (path: bigint): void;
9314 probe_failed (path: bigint, short_channel_id: bigint): void;
9315 probe_successful (path: bigint): void;
9319 export function LDKScoreUpdate_new(impl: LDKScoreUpdate): [bigint, number] {
9320 if(!isWasmInitialized) {
9321 throw new Error("initializeWasm() must be awaited first!");
9323 var new_obj_idx = js_objs.length;
9324 for (var i = 0; i < js_objs.length; i++) {
9325 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9327 js_objs[i] = new WeakRef(impl);
9328 return [wasm.TS_LDKScoreUpdate_new(i), i];
9330 // void ScoreUpdate_payment_path_failed LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id
9332 export function ScoreUpdate_payment_path_failed(this_arg: bigint, path: bigint, short_channel_id: bigint): void {
9333 if(!isWasmInitialized) {
9334 throw new Error("initializeWasm() must be awaited first!");
9336 const nativeResponseValue = wasm.TS_ScoreUpdate_payment_path_failed(this_arg, path, short_channel_id);
9337 // debug statements here
9339 // void ScoreUpdate_payment_path_successful LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path
9341 export function ScoreUpdate_payment_path_successful(this_arg: bigint, path: bigint): void {
9342 if(!isWasmInitialized) {
9343 throw new Error("initializeWasm() must be awaited first!");
9345 const nativeResponseValue = wasm.TS_ScoreUpdate_payment_path_successful(this_arg, path);
9346 // debug statements here
9348 // void ScoreUpdate_probe_failed LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id
9350 export function ScoreUpdate_probe_failed(this_arg: bigint, path: bigint, short_channel_id: bigint): void {
9351 if(!isWasmInitialized) {
9352 throw new Error("initializeWasm() must be awaited first!");
9354 const nativeResponseValue = wasm.TS_ScoreUpdate_probe_failed(this_arg, path, short_channel_id);
9355 // debug statements here
9357 // void ScoreUpdate_probe_successful LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path
9359 export function ScoreUpdate_probe_successful(this_arg: bigint, path: bigint): void {
9360 if(!isWasmInitialized) {
9361 throw new Error("initializeWasm() must be awaited first!");
9363 const nativeResponseValue = wasm.TS_ScoreUpdate_probe_successful(this_arg, path);
9364 // debug statements here
9367 export interface LDKLockableScore {
9368 read_lock (): bigint;
9369 write_lock (): bigint;
9373 export function LDKLockableScore_new(impl: LDKLockableScore): [bigint, number] {
9374 if(!isWasmInitialized) {
9375 throw new Error("initializeWasm() must be awaited first!");
9377 var new_obj_idx = js_objs.length;
9378 for (var i = 0; i < js_objs.length; i++) {
9379 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9381 js_objs[i] = new WeakRef(impl);
9382 return [wasm.TS_LDKLockableScore_new(i), i];
9384 // LDKScoreLookUp LockableScore_read_lock LDKLockableScore *NONNULL_PTR this_arg
9386 export function LockableScore_read_lock(this_arg: bigint): bigint {
9387 if(!isWasmInitialized) {
9388 throw new Error("initializeWasm() must be awaited first!");
9390 const nativeResponseValue = wasm.TS_LockableScore_read_lock(this_arg);
9391 return nativeResponseValue;
9393 // LDKScoreUpdate LockableScore_write_lock LDKLockableScore *NONNULL_PTR this_arg
9395 export function LockableScore_write_lock(this_arg: bigint): bigint {
9396 if(!isWasmInitialized) {
9397 throw new Error("initializeWasm() must be awaited first!");
9399 const nativeResponseValue = wasm.TS_LockableScore_write_lock(this_arg);
9400 return nativeResponseValue;
9403 export interface LDKWriteableScore {
9408 export function LDKWriteableScore_new(impl: LDKWriteableScore, LockableScore: number): [bigint, number] {
9409 if(!isWasmInitialized) {
9410 throw new Error("initializeWasm() must be awaited first!");
9412 var new_obj_idx = js_objs.length;
9413 for (var i = 0; i < js_objs.length; i++) {
9414 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9416 js_objs[i] = new WeakRef(impl);
9417 return [wasm.TS_LDKWriteableScore_new(i, LockableScore), i];
9419 // LDKCVec_u8Z WriteableScore_write LDKWriteableScore *NONNULL_PTR this_arg
9421 export function WriteableScore_write(this_arg: bigint): number {
9422 if(!isWasmInitialized) {
9423 throw new Error("initializeWasm() must be awaited first!");
9425 const nativeResponseValue = wasm.TS_WriteableScore_write(this_arg);
9426 return nativeResponseValue;
9429 export interface LDKPersister {
9430 persist_manager (channel_manager: bigint): bigint;
9431 persist_graph (network_graph: bigint): bigint;
9432 persist_scorer (scorer: bigint): bigint;
9436 export function LDKPersister_new(impl: LDKPersister): [bigint, number] {
9437 if(!isWasmInitialized) {
9438 throw new Error("initializeWasm() must be awaited first!");
9440 var new_obj_idx = js_objs.length;
9441 for (var i = 0; i < js_objs.length; i++) {
9442 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9444 js_objs[i] = new WeakRef(impl);
9445 return [wasm.TS_LDKPersister_new(i), i];
9447 // LDKCResult_NoneIOErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
9449 export function Persister_persist_manager(this_arg: bigint, channel_manager: bigint): bigint {
9450 if(!isWasmInitialized) {
9451 throw new Error("initializeWasm() must be awaited first!");
9453 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
9454 return nativeResponseValue;
9456 // LDKCResult_NoneIOErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
9458 export function Persister_persist_graph(this_arg: bigint, network_graph: bigint): bigint {
9459 if(!isWasmInitialized) {
9460 throw new Error("initializeWasm() must be awaited first!");
9462 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
9463 return nativeResponseValue;
9465 // LDKCResult_NoneIOErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKWriteableScore *NONNULL_PTR scorer
9467 export function Persister_persist_scorer(this_arg: bigint, scorer: bigint): bigint {
9468 if(!isWasmInitialized) {
9469 throw new Error("initializeWasm() must be awaited first!");
9471 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
9472 return nativeResponseValue;
9475 export interface LDKPersist {
9476 persist_new_channel (channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
9477 update_persisted_channel (channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
9481 export function LDKPersist_new(impl: LDKPersist): [bigint, number] {
9482 if(!isWasmInitialized) {
9483 throw new Error("initializeWasm() must be awaited first!");
9485 var new_obj_idx = js_objs.length;
9486 for (var i = 0; i < js_objs.length; i++) {
9487 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9489 js_objs[i] = new WeakRef(impl);
9490 return [wasm.TS_LDKPersist_new(i), i];
9492 // LDKChannelMonitorUpdateStatus Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
9494 export function Persist_persist_new_channel(this_arg: bigint, channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
9495 if(!isWasmInitialized) {
9496 throw new Error("initializeWasm() must be awaited first!");
9498 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
9499 return nativeResponseValue;
9501 // LDKChannelMonitorUpdateStatus Persist_update_persisted_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
9503 export function Persist_update_persisted_channel(this_arg: bigint, channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
9504 if(!isWasmInitialized) {
9505 throw new Error("initializeWasm() must be awaited first!");
9507 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
9508 return nativeResponseValue;
9511 export interface LDKFutureCallback {
9516 export function LDKFutureCallback_new(impl: LDKFutureCallback): [bigint, number] {
9517 if(!isWasmInitialized) {
9518 throw new Error("initializeWasm() must be awaited first!");
9520 var new_obj_idx = js_objs.length;
9521 for (var i = 0; i < js_objs.length; i++) {
9522 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9524 js_objs[i] = new WeakRef(impl);
9525 return [wasm.TS_LDKFutureCallback_new(i), i];
9527 // void FutureCallback_call LDKFutureCallback *NONNULL_PTR this_arg
9529 export function FutureCallback_call(this_arg: bigint): void {
9530 if(!isWasmInitialized) {
9531 throw new Error("initializeWasm() must be awaited first!");
9533 const nativeResponseValue = wasm.TS_FutureCallback_call(this_arg);
9534 // debug statements here
9537 export interface LDKListen {
9538 filtered_block_connected (header: number, txdata: number, height: number): void;
9539 block_connected (block: number, height: number): void;
9540 block_disconnected (header: number, height: number): void;
9544 export function LDKListen_new(impl: LDKListen): [bigint, number] {
9545 if(!isWasmInitialized) {
9546 throw new Error("initializeWasm() must be awaited first!");
9548 var new_obj_idx = js_objs.length;
9549 for (var i = 0; i < js_objs.length; i++) {
9550 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9552 js_objs[i] = new WeakRef(impl);
9553 return [wasm.TS_LDKListen_new(i), i];
9555 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
9557 export function Listen_filtered_block_connected(this_arg: bigint, header: number, txdata: number, height: number): void {
9558 if(!isWasmInitialized) {
9559 throw new Error("initializeWasm() must be awaited first!");
9561 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
9562 // debug statements here
9564 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
9566 export function Listen_block_connected(this_arg: bigint, block: number, height: number): void {
9567 if(!isWasmInitialized) {
9568 throw new Error("initializeWasm() must be awaited first!");
9570 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
9571 // debug statements here
9573 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
9575 export function Listen_block_disconnected(this_arg: bigint, header: number, height: number): void {
9576 if(!isWasmInitialized) {
9577 throw new Error("initializeWasm() must be awaited first!");
9579 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
9580 // debug statements here
9583 export interface LDKConfirm {
9584 transactions_confirmed (header: number, txdata: number, height: number): void;
9585 transaction_unconfirmed (txid: number): void;
9586 best_block_updated (header: number, height: number): void;
9587 get_relevant_txids (): number;
9591 export function LDKConfirm_new(impl: LDKConfirm): [bigint, number] {
9592 if(!isWasmInitialized) {
9593 throw new Error("initializeWasm() must be awaited first!");
9595 var new_obj_idx = js_objs.length;
9596 for (var i = 0; i < js_objs.length; i++) {
9597 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9599 js_objs[i] = new WeakRef(impl);
9600 return [wasm.TS_LDKConfirm_new(i), i];
9602 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
9604 export function Confirm_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number): void {
9605 if(!isWasmInitialized) {
9606 throw new Error("initializeWasm() must be awaited first!");
9608 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
9609 // debug statements here
9611 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
9613 export function Confirm_transaction_unconfirmed(this_arg: bigint, txid: number): void {
9614 if(!isWasmInitialized) {
9615 throw new Error("initializeWasm() must be awaited first!");
9617 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
9618 // debug statements here
9620 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
9622 export function Confirm_best_block_updated(this_arg: bigint, header: number, height: number): void {
9623 if(!isWasmInitialized) {
9624 throw new Error("initializeWasm() must be awaited first!");
9626 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
9627 // debug statements here
9629 // LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
9631 export function Confirm_get_relevant_txids(this_arg: bigint): number {
9632 if(!isWasmInitialized) {
9633 throw new Error("initializeWasm() must be awaited first!");
9635 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
9636 return nativeResponseValue;
9639 export interface LDKEventHandler {
9640 handle_event (event: bigint): void;
9644 export function LDKEventHandler_new(impl: LDKEventHandler): [bigint, number] {
9645 if(!isWasmInitialized) {
9646 throw new Error("initializeWasm() must be awaited first!");
9648 var new_obj_idx = js_objs.length;
9649 for (var i = 0; i < js_objs.length; i++) {
9650 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9652 js_objs[i] = new WeakRef(impl);
9653 return [wasm.TS_LDKEventHandler_new(i), i];
9655 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, struct LDKEvent event
9657 export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
9658 if(!isWasmInitialized) {
9659 throw new Error("initializeWasm() must be awaited first!");
9661 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
9662 // debug statements here
9665 export interface LDKEventsProvider {
9666 process_pending_events (handler: bigint): void;
9670 export function LDKEventsProvider_new(impl: LDKEventsProvider): [bigint, number] {
9671 if(!isWasmInitialized) {
9672 throw new Error("initializeWasm() must be awaited first!");
9674 var new_obj_idx = js_objs.length;
9675 for (var i = 0; i < js_objs.length; i++) {
9676 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9678 js_objs[i] = new WeakRef(impl);
9679 return [wasm.TS_LDKEventsProvider_new(i), i];
9681 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
9683 export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
9684 if(!isWasmInitialized) {
9685 throw new Error("initializeWasm() must be awaited first!");
9687 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
9688 // debug statements here
9691 export class LDKFailureCode {
9692 protected constructor() {}
9695 export function LDKFailureCode_ty_from_ptr(ptr: bigint): number {
9696 if(!isWasmInitialized) {
9697 throw new Error("initializeWasm() must be awaited first!");
9699 const nativeResponseValue = wasm.TS_LDKFailureCode_ty_from_ptr(ptr);
9700 return nativeResponseValue;
9703 export function LDKFailureCode_InvalidOnionPayload_get_invalid_onion_payload(ptr: bigint): bigint {
9704 if(!isWasmInitialized) {
9705 throw new Error("initializeWasm() must be awaited first!");
9707 const nativeResponseValue = wasm.TS_LDKFailureCode_InvalidOnionPayload_get_invalid_onion_payload(ptr);
9708 return nativeResponseValue;
9711 export interface LDKMessageSendEventsProvider {
9712 get_and_clear_pending_msg_events (): number;
9716 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): [bigint, number] {
9717 if(!isWasmInitialized) {
9718 throw new Error("initializeWasm() must be awaited first!");
9720 var new_obj_idx = js_objs.length;
9721 for (var i = 0; i < js_objs.length; i++) {
9722 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9724 js_objs[i] = new WeakRef(impl);
9725 return [wasm.TS_LDKMessageSendEventsProvider_new(i), i];
9727 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
9729 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
9730 if(!isWasmInitialized) {
9731 throw new Error("initializeWasm() must be awaited first!");
9733 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
9734 return nativeResponseValue;
9737 export interface LDKChannelMessageHandler {
9738 handle_open_channel (their_node_id: number, msg: bigint): void;
9739 handle_open_channel_v2 (their_node_id: number, msg: bigint): void;
9740 handle_accept_channel (their_node_id: number, msg: bigint): void;
9741 handle_accept_channel_v2 (their_node_id: number, msg: bigint): void;
9742 handle_funding_created (their_node_id: number, msg: bigint): void;
9743 handle_funding_signed (their_node_id: number, msg: bigint): void;
9744 handle_channel_ready (their_node_id: number, msg: bigint): void;
9745 handle_shutdown (their_node_id: number, msg: bigint): void;
9746 handle_closing_signed (their_node_id: number, msg: bigint): void;
9747 handle_tx_add_input (their_node_id: number, msg: bigint): void;
9748 handle_tx_add_output (their_node_id: number, msg: bigint): void;
9749 handle_tx_remove_input (their_node_id: number, msg: bigint): void;
9750 handle_tx_remove_output (their_node_id: number, msg: bigint): void;
9751 handle_tx_complete (their_node_id: number, msg: bigint): void;
9752 handle_tx_signatures (their_node_id: number, msg: bigint): void;
9753 handle_tx_init_rbf (their_node_id: number, msg: bigint): void;
9754 handle_tx_ack_rbf (their_node_id: number, msg: bigint): void;
9755 handle_tx_abort (their_node_id: number, msg: bigint): void;
9756 handle_update_add_htlc (their_node_id: number, msg: bigint): void;
9757 handle_update_fulfill_htlc (their_node_id: number, msg: bigint): void;
9758 handle_update_fail_htlc (their_node_id: number, msg: bigint): void;
9759 handle_update_fail_malformed_htlc (their_node_id: number, msg: bigint): void;
9760 handle_commitment_signed (their_node_id: number, msg: bigint): void;
9761 handle_revoke_and_ack (their_node_id: number, msg: bigint): void;
9762 handle_update_fee (their_node_id: number, msg: bigint): void;
9763 handle_announcement_signatures (their_node_id: number, msg: bigint): void;
9764 peer_disconnected (their_node_id: number): void;
9765 peer_connected (their_node_id: number, msg: bigint, inbound: boolean): bigint;
9766 handle_channel_reestablish (their_node_id: number, msg: bigint): void;
9767 handle_channel_update (their_node_id: number, msg: bigint): void;
9768 handle_error (their_node_id: number, msg: bigint): void;
9769 provided_node_features (): bigint;
9770 provided_init_features (their_node_id: number): bigint;
9771 get_chain_hashes (): bigint;
9775 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
9776 if(!isWasmInitialized) {
9777 throw new Error("initializeWasm() must be awaited first!");
9779 var new_obj_idx = js_objs.length;
9780 for (var i = 0; i < js_objs.length; i++) {
9781 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9783 js_objs[i] = new WeakRef(impl);
9784 return [wasm.TS_LDKChannelMessageHandler_new(i, MessageSendEventsProvider), i];
9786 // void ChannelMessageHandler_handle_open_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg
9788 export function ChannelMessageHandler_handle_open_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
9789 if(!isWasmInitialized) {
9790 throw new Error("initializeWasm() must be awaited first!");
9792 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, msg);
9793 // debug statements here
9795 // void ChannelMessageHandler_handle_open_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg
9797 export function ChannelMessageHandler_handle_open_channel_v2(this_arg: bigint, their_node_id: number, msg: bigint): void {
9798 if(!isWasmInitialized) {
9799 throw new Error("initializeWasm() must be awaited first!");
9801 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel_v2(this_arg, their_node_id, msg);
9802 // debug statements here
9804 // void ChannelMessageHandler_handle_accept_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg
9806 export function ChannelMessageHandler_handle_accept_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
9807 if(!isWasmInitialized) {
9808 throw new Error("initializeWasm() must be awaited first!");
9810 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, msg);
9811 // debug statements here
9813 // void ChannelMessageHandler_handle_accept_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg
9815 export function ChannelMessageHandler_handle_accept_channel_v2(this_arg: bigint, their_node_id: number, msg: bigint): void {
9816 if(!isWasmInitialized) {
9817 throw new Error("initializeWasm() must be awaited first!");
9819 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel_v2(this_arg, their_node_id, msg);
9820 // debug statements here
9822 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
9824 export function ChannelMessageHandler_handle_funding_created(this_arg: bigint, their_node_id: number, msg: bigint): void {
9825 if(!isWasmInitialized) {
9826 throw new Error("initializeWasm() must be awaited first!");
9828 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
9829 // debug statements here
9831 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
9833 export function ChannelMessageHandler_handle_funding_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
9834 if(!isWasmInitialized) {
9835 throw new Error("initializeWasm() must be awaited first!");
9837 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
9838 // debug statements here
9840 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
9842 export function ChannelMessageHandler_handle_channel_ready(this_arg: bigint, their_node_id: number, msg: bigint): void {
9843 if(!isWasmInitialized) {
9844 throw new Error("initializeWasm() must be awaited first!");
9846 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
9847 // debug statements here
9849 // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg
9851 export function ChannelMessageHandler_handle_shutdown(this_arg: bigint, their_node_id: number, msg: bigint): void {
9852 if(!isWasmInitialized) {
9853 throw new Error("initializeWasm() must be awaited first!");
9855 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, msg);
9856 // debug statements here
9858 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
9860 export function ChannelMessageHandler_handle_closing_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
9861 if(!isWasmInitialized) {
9862 throw new Error("initializeWasm() must be awaited first!");
9864 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
9865 // debug statements here
9867 // void ChannelMessageHandler_handle_tx_add_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg
9869 export function ChannelMessageHandler_handle_tx_add_input(this_arg: bigint, their_node_id: number, msg: bigint): void {
9870 if(!isWasmInitialized) {
9871 throw new Error("initializeWasm() must be awaited first!");
9873 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_add_input(this_arg, their_node_id, msg);
9874 // debug statements here
9876 // void ChannelMessageHandler_handle_tx_add_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg
9878 export function ChannelMessageHandler_handle_tx_add_output(this_arg: bigint, their_node_id: number, msg: bigint): void {
9879 if(!isWasmInitialized) {
9880 throw new Error("initializeWasm() must be awaited first!");
9882 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_add_output(this_arg, their_node_id, msg);
9883 // debug statements here
9885 // void ChannelMessageHandler_handle_tx_remove_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg
9887 export function ChannelMessageHandler_handle_tx_remove_input(this_arg: bigint, their_node_id: number, msg: bigint): void {
9888 if(!isWasmInitialized) {
9889 throw new Error("initializeWasm() must be awaited first!");
9891 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_remove_input(this_arg, their_node_id, msg);
9892 // debug statements here
9894 // void ChannelMessageHandler_handle_tx_remove_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg
9896 export function ChannelMessageHandler_handle_tx_remove_output(this_arg: bigint, their_node_id: number, msg: bigint): void {
9897 if(!isWasmInitialized) {
9898 throw new Error("initializeWasm() must be awaited first!");
9900 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_remove_output(this_arg, their_node_id, msg);
9901 // debug statements here
9903 // void ChannelMessageHandler_handle_tx_complete LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg
9905 export function ChannelMessageHandler_handle_tx_complete(this_arg: bigint, their_node_id: number, msg: bigint): void {
9906 if(!isWasmInitialized) {
9907 throw new Error("initializeWasm() must be awaited first!");
9909 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_complete(this_arg, their_node_id, msg);
9910 // debug statements here
9912 // void ChannelMessageHandler_handle_tx_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg
9914 export function ChannelMessageHandler_handle_tx_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
9915 if(!isWasmInitialized) {
9916 throw new Error("initializeWasm() must be awaited first!");
9918 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_signatures(this_arg, their_node_id, msg);
9919 // debug statements here
9921 // void ChannelMessageHandler_handle_tx_init_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg
9923 export function ChannelMessageHandler_handle_tx_init_rbf(this_arg: bigint, their_node_id: number, msg: bigint): void {
9924 if(!isWasmInitialized) {
9925 throw new Error("initializeWasm() must be awaited first!");
9927 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_init_rbf(this_arg, their_node_id, msg);
9928 // debug statements here
9930 // void ChannelMessageHandler_handle_tx_ack_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg
9932 export function ChannelMessageHandler_handle_tx_ack_rbf(this_arg: bigint, their_node_id: number, msg: bigint): void {
9933 if(!isWasmInitialized) {
9934 throw new Error("initializeWasm() must be awaited first!");
9936 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_ack_rbf(this_arg, their_node_id, msg);
9937 // debug statements here
9939 // void ChannelMessageHandler_handle_tx_abort LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg
9941 export function ChannelMessageHandler_handle_tx_abort(this_arg: bigint, their_node_id: number, msg: bigint): void {
9942 if(!isWasmInitialized) {
9943 throw new Error("initializeWasm() must be awaited first!");
9945 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_abort(this_arg, their_node_id, msg);
9946 // debug statements here
9948 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
9950 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9951 if(!isWasmInitialized) {
9952 throw new Error("initializeWasm() must be awaited first!");
9954 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
9955 // debug statements here
9957 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
9959 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9960 if(!isWasmInitialized) {
9961 throw new Error("initializeWasm() must be awaited first!");
9963 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
9964 // debug statements here
9966 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
9968 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9969 if(!isWasmInitialized) {
9970 throw new Error("initializeWasm() must be awaited first!");
9972 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
9973 // debug statements here
9975 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
9977 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
9978 if(!isWasmInitialized) {
9979 throw new Error("initializeWasm() must be awaited first!");
9981 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
9982 // debug statements here
9984 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
9986 export function ChannelMessageHandler_handle_commitment_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
9987 if(!isWasmInitialized) {
9988 throw new Error("initializeWasm() must be awaited first!");
9990 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
9991 // debug statements here
9993 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
9995 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: bigint, their_node_id: number, msg: bigint): void {
9996 if(!isWasmInitialized) {
9997 throw new Error("initializeWasm() must be awaited first!");
9999 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
10000 // debug statements here
10002 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
10004 export function ChannelMessageHandler_handle_update_fee(this_arg: bigint, their_node_id: number, msg: bigint): void {
10005 if(!isWasmInitialized) {
10006 throw new Error("initializeWasm() must be awaited first!");
10008 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
10009 // debug statements here
10011 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
10013 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
10014 if(!isWasmInitialized) {
10015 throw new Error("initializeWasm() must be awaited first!");
10017 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
10018 // debug statements here
10020 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10022 export function ChannelMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
10023 if(!isWasmInitialized) {
10024 throw new Error("initializeWasm() must be awaited first!");
10026 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id);
10027 // debug statements here
10029 // LDKCResult_NoneNoneZ ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound
10031 export function ChannelMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, msg: bigint, inbound: boolean): bigint {
10032 if(!isWasmInitialized) {
10033 throw new Error("initializeWasm() must be awaited first!");
10035 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg, inbound);
10036 return nativeResponseValue;
10038 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
10040 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: bigint, their_node_id: number, msg: bigint): void {
10041 if(!isWasmInitialized) {
10042 throw new Error("initializeWasm() must be awaited first!");
10044 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
10045 // debug statements here
10047 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
10049 export function ChannelMessageHandler_handle_channel_update(this_arg: bigint, their_node_id: number, msg: bigint): void {
10050 if(!isWasmInitialized) {
10051 throw new Error("initializeWasm() must be awaited first!");
10053 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
10054 // debug statements here
10056 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
10058 export function ChannelMessageHandler_handle_error(this_arg: bigint, their_node_id: number, msg: bigint): void {
10059 if(!isWasmInitialized) {
10060 throw new Error("initializeWasm() must be awaited first!");
10062 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
10063 // debug statements here
10065 // LDKNodeFeatures ChannelMessageHandler_provided_node_features LDKChannelMessageHandler *NONNULL_PTR this_arg
10067 export function ChannelMessageHandler_provided_node_features(this_arg: bigint): bigint {
10068 if(!isWasmInitialized) {
10069 throw new Error("initializeWasm() must be awaited first!");
10071 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_node_features(this_arg);
10072 return nativeResponseValue;
10074 // LDKInitFeatures ChannelMessageHandler_provided_init_features LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10076 export function ChannelMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
10077 if(!isWasmInitialized) {
10078 throw new Error("initializeWasm() must be awaited first!");
10080 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_init_features(this_arg, their_node_id);
10081 return nativeResponseValue;
10083 // LDKCOption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler_get_chain_hashes LDKChannelMessageHandler *NONNULL_PTR this_arg
10085 export function ChannelMessageHandler_get_chain_hashes(this_arg: bigint): bigint {
10086 if(!isWasmInitialized) {
10087 throw new Error("initializeWasm() must be awaited first!");
10089 const nativeResponseValue = wasm.TS_ChannelMessageHandler_get_chain_hashes(this_arg);
10090 return nativeResponseValue;
10093 export interface LDKOffersMessageHandler {
10094 handle_message (message: bigint): bigint;
10095 release_pending_messages (): number;
10099 export function LDKOffersMessageHandler_new(impl: LDKOffersMessageHandler): [bigint, number] {
10100 if(!isWasmInitialized) {
10101 throw new Error("initializeWasm() must be awaited first!");
10103 var new_obj_idx = js_objs.length;
10104 for (var i = 0; i < js_objs.length; i++) {
10105 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10107 js_objs[i] = new WeakRef(impl);
10108 return [wasm.TS_LDKOffersMessageHandler_new(i), i];
10110 // LDKCOption_OffersMessageZ OffersMessageHandler_handle_message LDKOffersMessageHandler *NONNULL_PTR this_arg, struct LDKOffersMessage message
10112 export function OffersMessageHandler_handle_message(this_arg: bigint, message: bigint): bigint {
10113 if(!isWasmInitialized) {
10114 throw new Error("initializeWasm() must be awaited first!");
10116 const nativeResponseValue = wasm.TS_OffersMessageHandler_handle_message(this_arg, message);
10117 return nativeResponseValue;
10119 // LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ OffersMessageHandler_release_pending_messages LDKOffersMessageHandler *NONNULL_PTR this_arg
10121 export function OffersMessageHandler_release_pending_messages(this_arg: bigint): number {
10122 if(!isWasmInitialized) {
10123 throw new Error("initializeWasm() must be awaited first!");
10125 const nativeResponseValue = wasm.TS_OffersMessageHandler_release_pending_messages(this_arg);
10126 return nativeResponseValue;
10129 export interface LDKRoutingMessageHandler {
10130 handle_node_announcement (msg: bigint): bigint;
10131 handle_channel_announcement (msg: bigint): bigint;
10132 handle_channel_update (msg: bigint): bigint;
10133 get_next_channel_announcement (starting_point: bigint): bigint;
10134 get_next_node_announcement (starting_point: bigint): bigint;
10135 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
10136 handle_reply_channel_range (their_node_id: number, msg: bigint): bigint;
10137 handle_reply_short_channel_ids_end (their_node_id: number, msg: bigint): bigint;
10138 handle_query_channel_range (their_node_id: number, msg: bigint): bigint;
10139 handle_query_short_channel_ids (their_node_id: number, msg: bigint): bigint;
10140 processing_queue_high (): boolean;
10141 provided_node_features (): bigint;
10142 provided_init_features (their_node_id: number): bigint;
10146 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
10147 if(!isWasmInitialized) {
10148 throw new Error("initializeWasm() must be awaited first!");
10150 var new_obj_idx = js_objs.length;
10151 for (var i = 0; i < js_objs.length; i++) {
10152 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10154 js_objs[i] = new WeakRef(impl);
10155 return [wasm.TS_LDKRoutingMessageHandler_new(i, MessageSendEventsProvider), i];
10157 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
10159 export function RoutingMessageHandler_handle_node_announcement(this_arg: bigint, msg: bigint): bigint {
10160 if(!isWasmInitialized) {
10161 throw new Error("initializeWasm() must be awaited first!");
10163 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
10164 return nativeResponseValue;
10166 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
10168 export function RoutingMessageHandler_handle_channel_announcement(this_arg: bigint, msg: bigint): bigint {
10169 if(!isWasmInitialized) {
10170 throw new Error("initializeWasm() must be awaited first!");
10172 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
10173 return nativeResponseValue;
10175 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
10177 export function RoutingMessageHandler_handle_channel_update(this_arg: bigint, msg: bigint): bigint {
10178 if(!isWasmInitialized) {
10179 throw new Error("initializeWasm() must be awaited first!");
10181 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
10182 return nativeResponseValue;
10184 // LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point
10186 export function RoutingMessageHandler_get_next_channel_announcement(this_arg: bigint, starting_point: bigint): bigint {
10187 if(!isWasmInitialized) {
10188 throw new Error("initializeWasm() must be awaited first!");
10190 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcement(this_arg, starting_point);
10191 return nativeResponseValue;
10193 // LDKNodeAnnouncement RoutingMessageHandler_get_next_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKNodeId starting_point
10195 export function RoutingMessageHandler_get_next_node_announcement(this_arg: bigint, starting_point: bigint): bigint {
10196 if(!isWasmInitialized) {
10197 throw new Error("initializeWasm() must be awaited first!");
10199 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcement(this_arg, starting_point);
10200 return nativeResponseValue;
10202 // LDKCResult_NoneNoneZ RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
10204 export function RoutingMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
10205 if(!isWasmInitialized) {
10206 throw new Error("initializeWasm() must be awaited first!");
10208 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
10209 return nativeResponseValue;
10211 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
10213 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
10214 if(!isWasmInitialized) {
10215 throw new Error("initializeWasm() must be awaited first!");
10217 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
10218 return nativeResponseValue;
10220 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
10222 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
10223 if(!isWasmInitialized) {
10224 throw new Error("initializeWasm() must be awaited first!");
10226 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
10227 return nativeResponseValue;
10229 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
10231 export function RoutingMessageHandler_handle_query_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
10232 if(!isWasmInitialized) {
10233 throw new Error("initializeWasm() must be awaited first!");
10235 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
10236 return nativeResponseValue;
10238 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
10240 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
10241 if(!isWasmInitialized) {
10242 throw new Error("initializeWasm() must be awaited first!");
10244 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
10245 return nativeResponseValue;
10247 // bool RoutingMessageHandler_processing_queue_high LDKRoutingMessageHandler *NONNULL_PTR this_arg
10249 export function RoutingMessageHandler_processing_queue_high(this_arg: bigint): boolean {
10250 if(!isWasmInitialized) {
10251 throw new Error("initializeWasm() must be awaited first!");
10253 const nativeResponseValue = wasm.TS_RoutingMessageHandler_processing_queue_high(this_arg);
10254 return nativeResponseValue;
10256 // LDKNodeFeatures RoutingMessageHandler_provided_node_features LDKRoutingMessageHandler *NONNULL_PTR this_arg
10258 export function RoutingMessageHandler_provided_node_features(this_arg: bigint): bigint {
10259 if(!isWasmInitialized) {
10260 throw new Error("initializeWasm() must be awaited first!");
10262 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_node_features(this_arg);
10263 return nativeResponseValue;
10265 // LDKInitFeatures RoutingMessageHandler_provided_init_features LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10267 export function RoutingMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
10268 if(!isWasmInitialized) {
10269 throw new Error("initializeWasm() must be awaited first!");
10271 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_init_features(this_arg, their_node_id);
10272 return nativeResponseValue;
10275 export interface LDKOnionMessageHandler {
10276 handle_onion_message (peer_node_id: number, msg: bigint): void;
10277 next_onion_message_for_peer (peer_node_id: number): bigint;
10278 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
10279 peer_disconnected (their_node_id: number): void;
10280 provided_node_features (): bigint;
10281 provided_init_features (their_node_id: number): bigint;
10285 export function LDKOnionMessageHandler_new(impl: LDKOnionMessageHandler): [bigint, number] {
10286 if(!isWasmInitialized) {
10287 throw new Error("initializeWasm() must be awaited first!");
10289 var new_obj_idx = js_objs.length;
10290 for (var i = 0; i < js_objs.length; i++) {
10291 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10293 js_objs[i] = new WeakRef(impl);
10294 return [wasm.TS_LDKOnionMessageHandler_new(i), i];
10296 // void OnionMessageHandler_handle_onion_message LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg
10298 export function OnionMessageHandler_handle_onion_message(this_arg: bigint, peer_node_id: number, msg: bigint): void {
10299 if(!isWasmInitialized) {
10300 throw new Error("initializeWasm() must be awaited first!");
10302 const nativeResponseValue = wasm.TS_OnionMessageHandler_handle_onion_message(this_arg, peer_node_id, msg);
10303 // debug statements here
10305 // LDKOnionMessage OnionMessageHandler_next_onion_message_for_peer LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
10307 export function OnionMessageHandler_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
10308 if(!isWasmInitialized) {
10309 throw new Error("initializeWasm() must be awaited first!");
10311 const nativeResponseValue = wasm.TS_OnionMessageHandler_next_onion_message_for_peer(this_arg, peer_node_id);
10312 return nativeResponseValue;
10314 // LDKCResult_NoneNoneZ OnionMessageHandler_peer_connected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
10316 export function OnionMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
10317 if(!isWasmInitialized) {
10318 throw new Error("initializeWasm() must be awaited first!");
10320 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
10321 return nativeResponseValue;
10323 // void OnionMessageHandler_peer_disconnected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10325 export function OnionMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
10326 if(!isWasmInitialized) {
10327 throw new Error("initializeWasm() must be awaited first!");
10329 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_disconnected(this_arg, their_node_id);
10330 // debug statements here
10332 // LDKNodeFeatures OnionMessageHandler_provided_node_features LDKOnionMessageHandler *NONNULL_PTR this_arg
10334 export function OnionMessageHandler_provided_node_features(this_arg: bigint): bigint {
10335 if(!isWasmInitialized) {
10336 throw new Error("initializeWasm() must be awaited first!");
10338 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_node_features(this_arg);
10339 return nativeResponseValue;
10341 // LDKInitFeatures OnionMessageHandler_provided_init_features LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10343 export function OnionMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
10344 if(!isWasmInitialized) {
10345 throw new Error("initializeWasm() must be awaited first!");
10347 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_init_features(this_arg, their_node_id);
10348 return nativeResponseValue;
10351 export interface LDKCustomMessageReader {
10352 read (message_type: number, buffer: number): bigint;
10356 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): [bigint, number] {
10357 if(!isWasmInitialized) {
10358 throw new Error("initializeWasm() must be awaited first!");
10360 var new_obj_idx = js_objs.length;
10361 for (var i = 0; i < js_objs.length; i++) {
10362 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10364 js_objs[i] = new WeakRef(impl);
10365 return [wasm.TS_LDKCustomMessageReader_new(i), i];
10367 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
10369 export function CustomMessageReader_read(this_arg: bigint, message_type: number, buffer: number): bigint {
10370 if(!isWasmInitialized) {
10371 throw new Error("initializeWasm() must be awaited first!");
10373 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
10374 return nativeResponseValue;
10377 export interface LDKCustomMessageHandler {
10378 handle_custom_message (msg: bigint, sender_node_id: number): bigint;
10379 get_and_clear_pending_msg (): number;
10380 provided_node_features (): bigint;
10381 provided_init_features (their_node_id: number): bigint;
10385 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: number): [bigint, number] {
10386 if(!isWasmInitialized) {
10387 throw new Error("initializeWasm() must be awaited first!");
10389 var new_obj_idx = js_objs.length;
10390 for (var i = 0; i < js_objs.length; i++) {
10391 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10393 js_objs[i] = new WeakRef(impl);
10394 return [wasm.TS_LDKCustomMessageHandler_new(i, CustomMessageReader), i];
10396 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
10398 export function CustomMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint, sender_node_id: number): bigint {
10399 if(!isWasmInitialized) {
10400 throw new Error("initializeWasm() must be awaited first!");
10402 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
10403 return nativeResponseValue;
10405 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
10407 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: bigint): number {
10408 if(!isWasmInitialized) {
10409 throw new Error("initializeWasm() must be awaited first!");
10411 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
10412 return nativeResponseValue;
10414 // LDKNodeFeatures CustomMessageHandler_provided_node_features LDKCustomMessageHandler *NONNULL_PTR this_arg
10416 export function CustomMessageHandler_provided_node_features(this_arg: bigint): bigint {
10417 if(!isWasmInitialized) {
10418 throw new Error("initializeWasm() must be awaited first!");
10420 const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_node_features(this_arg);
10421 return nativeResponseValue;
10423 // LDKInitFeatures CustomMessageHandler_provided_init_features LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10425 export function CustomMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
10426 if(!isWasmInitialized) {
10427 throw new Error("initializeWasm() must be awaited first!");
10429 const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_init_features(this_arg, their_node_id);
10430 return nativeResponseValue;
10433 export interface LDKCustomOnionMessageHandler {
10434 handle_custom_message (msg: bigint): bigint;
10435 read_custom_message (message_type: bigint, buffer: number): bigint;
10436 release_pending_custom_messages (): number;
10440 export function LDKCustomOnionMessageHandler_new(impl: LDKCustomOnionMessageHandler): [bigint, number] {
10441 if(!isWasmInitialized) {
10442 throw new Error("initializeWasm() must be awaited first!");
10444 var new_obj_idx = js_objs.length;
10445 for (var i = 0; i < js_objs.length; i++) {
10446 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10448 js_objs[i] = new WeakRef(impl);
10449 return [wasm.TS_LDKCustomOnionMessageHandler_new(i), i];
10451 // LDKCOption_OnionMessageContentsZ CustomOnionMessageHandler_handle_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, struct LDKOnionMessageContents msg
10453 export function CustomOnionMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint): bigint {
10454 if(!isWasmInitialized) {
10455 throw new Error("initializeWasm() must be awaited first!");
10457 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_handle_custom_message(this_arg, msg);
10458 return nativeResponseValue;
10460 // LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler_read_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, uint64_t message_type, struct LDKu8slice buffer
10462 export function CustomOnionMessageHandler_read_custom_message(this_arg: bigint, message_type: bigint, buffer: number): bigint {
10463 if(!isWasmInitialized) {
10464 throw new Error("initializeWasm() must be awaited first!");
10466 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_read_custom_message(this_arg, message_type, buffer);
10467 return nativeResponseValue;
10469 // LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ CustomOnionMessageHandler_release_pending_custom_messages LDKCustomOnionMessageHandler *NONNULL_PTR this_arg
10471 export function CustomOnionMessageHandler_release_pending_custom_messages(this_arg: bigint): number {
10472 if(!isWasmInitialized) {
10473 throw new Error("initializeWasm() must be awaited first!");
10475 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_release_pending_custom_messages(this_arg);
10476 return nativeResponseValue;
10479 export interface LDKSocketDescriptor {
10480 send_data (data: number, resume_read: boolean): number;
10481 disconnect_socket (): void;
10482 eq (other_arg: bigint): boolean;
10487 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): [bigint, number] {
10488 if(!isWasmInitialized) {
10489 throw new Error("initializeWasm() must be awaited first!");
10491 var new_obj_idx = js_objs.length;
10492 for (var i = 0; i < js_objs.length; i++) {
10493 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10495 js_objs[i] = new WeakRef(impl);
10496 return [wasm.TS_LDKSocketDescriptor_new(i), i];
10498 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
10500 export function SocketDescriptor_send_data(this_arg: bigint, data: number, resume_read: boolean): number {
10501 if(!isWasmInitialized) {
10502 throw new Error("initializeWasm() must be awaited first!");
10504 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
10505 return nativeResponseValue;
10507 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
10509 export function SocketDescriptor_disconnect_socket(this_arg: bigint): void {
10510 if(!isWasmInitialized) {
10511 throw new Error("initializeWasm() must be awaited first!");
10513 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
10514 // debug statements here
10516 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
10518 export function SocketDescriptor_hash(this_arg: bigint): bigint {
10519 if(!isWasmInitialized) {
10520 throw new Error("initializeWasm() must be awaited first!");
10522 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
10523 return nativeResponseValue;
10526 export class LDKEffectiveCapacity {
10527 protected constructor() {}
10530 export function LDKEffectiveCapacity_ty_from_ptr(ptr: bigint): number {
10531 if(!isWasmInitialized) {
10532 throw new Error("initializeWasm() must be awaited first!");
10534 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
10535 return nativeResponseValue;
10538 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: bigint): bigint {
10539 if(!isWasmInitialized) {
10540 throw new Error("initializeWasm() must be awaited first!");
10542 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
10543 return nativeResponseValue;
10546 export function LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr: bigint): bigint {
10547 if(!isWasmInitialized) {
10548 throw new Error("initializeWasm() must be awaited first!");
10550 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr);
10551 return nativeResponseValue;
10554 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: bigint): bigint {
10555 if(!isWasmInitialized) {
10556 throw new Error("initializeWasm() must be awaited first!");
10558 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
10559 return nativeResponseValue;
10562 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): bigint {
10563 if(!isWasmInitialized) {
10564 throw new Error("initializeWasm() must be awaited first!");
10566 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
10567 return nativeResponseValue;
10570 export function LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr: bigint): bigint {
10571 if(!isWasmInitialized) {
10572 throw new Error("initializeWasm() must be awaited first!");
10574 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr);
10575 return nativeResponseValue;
10578 export class LDKPayee {
10579 protected constructor() {}
10582 export function LDKPayee_ty_from_ptr(ptr: bigint): number {
10583 if(!isWasmInitialized) {
10584 throw new Error("initializeWasm() must be awaited first!");
10586 const nativeResponseValue = wasm.TS_LDKPayee_ty_from_ptr(ptr);
10587 return nativeResponseValue;
10590 export function LDKPayee_Blinded_get_route_hints(ptr: bigint): number {
10591 if(!isWasmInitialized) {
10592 throw new Error("initializeWasm() must be awaited first!");
10594 const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_route_hints(ptr);
10595 return nativeResponseValue;
10598 export function LDKPayee_Blinded_get_features(ptr: bigint): bigint {
10599 if(!isWasmInitialized) {
10600 throw new Error("initializeWasm() must be awaited first!");
10602 const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_features(ptr);
10603 return nativeResponseValue;
10606 export function LDKPayee_Clear_get_node_id(ptr: bigint): number {
10607 if(!isWasmInitialized) {
10608 throw new Error("initializeWasm() must be awaited first!");
10610 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_node_id(ptr);
10611 return nativeResponseValue;
10614 export function LDKPayee_Clear_get_route_hints(ptr: bigint): number {
10615 if(!isWasmInitialized) {
10616 throw new Error("initializeWasm() must be awaited first!");
10618 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_route_hints(ptr);
10619 return nativeResponseValue;
10622 export function LDKPayee_Clear_get_features(ptr: bigint): bigint {
10623 if(!isWasmInitialized) {
10624 throw new Error("initializeWasm() must be awaited first!");
10626 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_features(ptr);
10627 return nativeResponseValue;
10630 export function LDKPayee_Clear_get_final_cltv_expiry_delta(ptr: bigint): number {
10631 if(!isWasmInitialized) {
10632 throw new Error("initializeWasm() must be awaited first!");
10634 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_final_cltv_expiry_delta(ptr);
10635 return nativeResponseValue;
10638 export interface LDKScore {
10643 export function LDKScore_new(impl: LDKScore, ScoreLookUp: number, ScoreUpdate: number): [bigint, number] {
10644 if(!isWasmInitialized) {
10645 throw new Error("initializeWasm() must be awaited first!");
10647 var new_obj_idx = js_objs.length;
10648 for (var i = 0; i < js_objs.length; i++) {
10649 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10651 js_objs[i] = new WeakRef(impl);
10652 return [wasm.TS_LDKScore_new(i, ScoreLookUp, ScoreUpdate), i];
10654 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
10656 export function Score_write(this_arg: bigint): number {
10657 if(!isWasmInitialized) {
10658 throw new Error("initializeWasm() must be awaited first!");
10660 const nativeResponseValue = wasm.TS_Score_write(this_arg);
10661 return nativeResponseValue;
10664 export interface LDKMessageRouter {
10665 find_path (sender: number, peers: number, destination: bigint): bigint;
10669 export function LDKMessageRouter_new(impl: LDKMessageRouter): [bigint, number] {
10670 if(!isWasmInitialized) {
10671 throw new Error("initializeWasm() must be awaited first!");
10673 var new_obj_idx = js_objs.length;
10674 for (var i = 0; i < js_objs.length; i++) {
10675 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10677 js_objs[i] = new WeakRef(impl);
10678 return [wasm.TS_LDKMessageRouter_new(i), i];
10680 // LDKCResult_OnionMessagePathNoneZ MessageRouter_find_path LDKMessageRouter *NONNULL_PTR this_arg, struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination
10682 export function MessageRouter_find_path(this_arg: bigint, sender: number, peers: number, destination: bigint): bigint {
10683 if(!isWasmInitialized) {
10684 throw new Error("initializeWasm() must be awaited first!");
10686 const nativeResponseValue = wasm.TS_MessageRouter_find_path(this_arg, sender, peers, destination);
10687 return nativeResponseValue;
10690 export interface LDKCoinSelectionSource {
10691 select_confirmed_utxos (claim_id: number, must_spend: number, must_pay_to: number, target_feerate_sat_per_1000_weight: number): bigint;
10692 sign_tx (tx: number): bigint;
10696 export function LDKCoinSelectionSource_new(impl: LDKCoinSelectionSource): [bigint, number] {
10697 if(!isWasmInitialized) {
10698 throw new Error("initializeWasm() must be awaited first!");
10700 var new_obj_idx = js_objs.length;
10701 for (var i = 0; i < js_objs.length; i++) {
10702 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10704 js_objs[i] = new WeakRef(impl);
10705 return [wasm.TS_LDKCoinSelectionSource_new(i), i];
10707 // 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
10709 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 {
10710 if(!isWasmInitialized) {
10711 throw new Error("initializeWasm() must be awaited first!");
10713 const nativeResponseValue = wasm.TS_CoinSelectionSource_select_confirmed_utxos(this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
10714 return nativeResponseValue;
10716 // LDKCResult_TransactionNoneZ CoinSelectionSource_sign_tx LDKCoinSelectionSource *NONNULL_PTR this_arg, struct LDKTransaction tx
10718 export function CoinSelectionSource_sign_tx(this_arg: bigint, tx: number): bigint {
10719 if(!isWasmInitialized) {
10720 throw new Error("initializeWasm() must be awaited first!");
10722 const nativeResponseValue = wasm.TS_CoinSelectionSource_sign_tx(this_arg, tx);
10723 return nativeResponseValue;
10726 export interface LDKWalletSource {
10727 list_confirmed_utxos (): bigint;
10728 get_change_script (): bigint;
10729 sign_tx (tx: number): bigint;
10733 export function LDKWalletSource_new(impl: LDKWalletSource): [bigint, number] {
10734 if(!isWasmInitialized) {
10735 throw new Error("initializeWasm() must be awaited first!");
10737 var new_obj_idx = js_objs.length;
10738 for (var i = 0; i < js_objs.length; i++) {
10739 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10741 js_objs[i] = new WeakRef(impl);
10742 return [wasm.TS_LDKWalletSource_new(i), i];
10744 // LDKCResult_CVec_UtxoZNoneZ WalletSource_list_confirmed_utxos LDKWalletSource *NONNULL_PTR this_arg
10746 export function WalletSource_list_confirmed_utxos(this_arg: bigint): bigint {
10747 if(!isWasmInitialized) {
10748 throw new Error("initializeWasm() must be awaited first!");
10750 const nativeResponseValue = wasm.TS_WalletSource_list_confirmed_utxos(this_arg);
10751 return nativeResponseValue;
10753 // LDKCResult_CVec_u8ZNoneZ WalletSource_get_change_script LDKWalletSource *NONNULL_PTR this_arg
10755 export function WalletSource_get_change_script(this_arg: bigint): bigint {
10756 if(!isWasmInitialized) {
10757 throw new Error("initializeWasm() must be awaited first!");
10759 const nativeResponseValue = wasm.TS_WalletSource_get_change_script(this_arg);
10760 return nativeResponseValue;
10762 // LDKCResult_TransactionNoneZ WalletSource_sign_tx LDKWalletSource *NONNULL_PTR this_arg, struct LDKTransaction tx
10764 export function WalletSource_sign_tx(this_arg: bigint, tx: number): bigint {
10765 if(!isWasmInitialized) {
10766 throw new Error("initializeWasm() must be awaited first!");
10768 const nativeResponseValue = wasm.TS_WalletSource_sign_tx(this_arg, tx);
10769 return nativeResponseValue;
10772 export class LDKGossipSync {
10773 protected constructor() {}
10776 export function LDKGossipSync_ty_from_ptr(ptr: bigint): number {
10777 if(!isWasmInitialized) {
10778 throw new Error("initializeWasm() must be awaited first!");
10780 const nativeResponseValue = wasm.TS_LDKGossipSync_ty_from_ptr(ptr);
10781 return nativeResponseValue;
10784 export function LDKGossipSync_P2P_get_p2p(ptr: bigint): bigint {
10785 if(!isWasmInitialized) {
10786 throw new Error("initializeWasm() must be awaited first!");
10788 const nativeResponseValue = wasm.TS_LDKGossipSync_P2P_get_p2p(ptr);
10789 return nativeResponseValue;
10792 export function LDKGossipSync_Rapid_get_rapid(ptr: bigint): bigint {
10793 if(!isWasmInitialized) {
10794 throw new Error("initializeWasm() must be awaited first!");
10796 const nativeResponseValue = wasm.TS_LDKGossipSync_Rapid_get_rapid(ptr);
10797 return nativeResponseValue;
10800 export class LDKFallback {
10801 protected constructor() {}
10804 export function LDKFallback_ty_from_ptr(ptr: bigint): number {
10805 if(!isWasmInitialized) {
10806 throw new Error("initializeWasm() must be awaited first!");
10808 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
10809 return nativeResponseValue;
10812 export function LDKFallback_SegWitProgram_get_version(ptr: bigint): number {
10813 if(!isWasmInitialized) {
10814 throw new Error("initializeWasm() must be awaited first!");
10816 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
10817 return nativeResponseValue;
10820 export function LDKFallback_SegWitProgram_get_program(ptr: bigint): number {
10821 if(!isWasmInitialized) {
10822 throw new Error("initializeWasm() must be awaited first!");
10824 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
10825 return nativeResponseValue;
10828 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: bigint): number {
10829 if(!isWasmInitialized) {
10830 throw new Error("initializeWasm() must be awaited first!");
10832 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
10833 return nativeResponseValue;
10836 export function LDKFallback_ScriptHash_get_script_hash(ptr: bigint): number {
10837 if(!isWasmInitialized) {
10838 throw new Error("initializeWasm() must be awaited first!");
10840 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
10841 return nativeResponseValue;
10843 // struct LDKStr _ldk_get_compiled_version(void);
10845 export function _ldk_get_compiled_version(): number {
10846 if(!isWasmInitialized) {
10847 throw new Error("initializeWasm() must be awaited first!");
10849 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
10850 return nativeResponseValue;
10852 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
10854 export function _ldk_c_bindings_get_compiled_version(): number {
10855 if(!isWasmInitialized) {
10856 throw new Error("initializeWasm() must be awaited first!");
10858 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
10859 return nativeResponseValue;
10861 // struct LDKSixteenBytes U128_le_bytes(struct LDKU128 val);
10863 export function U128_le_bytes(val: number): number {
10864 if(!isWasmInitialized) {
10865 throw new Error("initializeWasm() must be awaited first!");
10867 const nativeResponseValue = wasm.TS_U128_le_bytes(val);
10868 return nativeResponseValue;
10870 // struct LDKU128 U128_new(struct LDKSixteenBytes le_bytes);
10872 export function U128_new(le_bytes: number): number {
10873 if(!isWasmInitialized) {
10874 throw new Error("initializeWasm() must be awaited first!");
10876 const nativeResponseValue = wasm.TS_U128_new(le_bytes);
10877 return nativeResponseValue;
10879 // struct LDKBigEndianScalar BigEndianScalar_new(struct LDKThirtyTwoBytes big_endian_bytes);
10881 export function BigEndianScalar_new(big_endian_bytes: number): bigint {
10882 if(!isWasmInitialized) {
10883 throw new Error("initializeWasm() must be awaited first!");
10885 const nativeResponseValue = wasm.TS_BigEndianScalar_new(big_endian_bytes);
10886 return nativeResponseValue;
10888 // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
10890 export function Bech32Error_clone_ptr(arg: bigint): bigint {
10891 if(!isWasmInitialized) {
10892 throw new Error("initializeWasm() must be awaited first!");
10894 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
10895 return nativeResponseValue;
10897 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
10899 export function Bech32Error_clone(orig: bigint): bigint {
10900 if(!isWasmInitialized) {
10901 throw new Error("initializeWasm() must be awaited first!");
10903 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
10904 return nativeResponseValue;
10906 // void Bech32Error_free(struct LDKBech32Error o);
10908 export function Bech32Error_free(o: bigint): void {
10909 if(!isWasmInitialized) {
10910 throw new Error("initializeWasm() must be awaited first!");
10912 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
10913 // debug statements here
10915 // void Transaction_free(struct LDKTransaction _res);
10917 export function Transaction_free(_res: number): void {
10918 if(!isWasmInitialized) {
10919 throw new Error("initializeWasm() must be awaited first!");
10921 const nativeResponseValue = wasm.TS_Transaction_free(_res);
10922 // debug statements here
10924 // void Witness_free(struct LDKWitness _res);
10926 export function Witness_free(_res: number): void {
10927 if(!isWasmInitialized) {
10928 throw new Error("initializeWasm() must be awaited first!");
10930 const nativeResponseValue = wasm.TS_Witness_free(_res);
10931 // debug statements here
10933 // void TxIn_free(struct LDKTxIn _res);
10935 export function TxIn_free(_res: bigint): void {
10936 if(!isWasmInitialized) {
10937 throw new Error("initializeWasm() must be awaited first!");
10939 const nativeResponseValue = wasm.TS_TxIn_free(_res);
10940 // debug statements here
10942 // struct LDKTxIn TxIn_new(struct LDKWitness witness, struct LDKCVec_u8Z script_sig, uint32_t sequence, struct LDKThirtyTwoBytes previous_txid, uint32_t previous_vout);
10944 export function TxIn_new(witness: number, script_sig: number, sequence: number, previous_txid: number, previous_vout: number): bigint {
10945 if(!isWasmInitialized) {
10946 throw new Error("initializeWasm() must be awaited first!");
10948 const nativeResponseValue = wasm.TS_TxIn_new(witness, script_sig, sequence, previous_txid, previous_vout);
10949 return nativeResponseValue;
10951 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
10953 export function TxOut_new(script_pubkey: number, value: bigint): bigint {
10954 if(!isWasmInitialized) {
10955 throw new Error("initializeWasm() must be awaited first!");
10957 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
10958 return nativeResponseValue;
10960 // void TxOut_free(struct LDKTxOut _res);
10962 export function TxOut_free(_res: bigint): void {
10963 if(!isWasmInitialized) {
10964 throw new Error("initializeWasm() must be awaited first!");
10966 const nativeResponseValue = wasm.TS_TxOut_free(_res);
10967 // debug statements here
10969 // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
10971 export function TxOut_clone_ptr(arg: bigint): bigint {
10972 if(!isWasmInitialized) {
10973 throw new Error("initializeWasm() must be awaited first!");
10975 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
10976 return nativeResponseValue;
10978 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
10980 export function TxOut_clone(orig: bigint): bigint {
10981 if(!isWasmInitialized) {
10982 throw new Error("initializeWasm() must be awaited first!");
10984 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
10985 return nativeResponseValue;
10987 // void Str_free(struct LDKStr _res);
10989 export function Str_free(_res: number): void {
10990 if(!isWasmInitialized) {
10991 throw new Error("initializeWasm() must be awaited first!");
10993 const nativeResponseValue = wasm.TS_Str_free(_res);
10994 // debug statements here
10996 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
10998 export function COption_u64Z_some(o: bigint): bigint {
10999 if(!isWasmInitialized) {
11000 throw new Error("initializeWasm() must be awaited first!");
11002 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
11003 return nativeResponseValue;
11005 // struct LDKCOption_u64Z COption_u64Z_none(void);
11007 export function COption_u64Z_none(): bigint {
11008 if(!isWasmInitialized) {
11009 throw new Error("initializeWasm() must be awaited first!");
11011 const nativeResponseValue = wasm.TS_COption_u64Z_none();
11012 return nativeResponseValue;
11014 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
11016 export function COption_u64Z_free(_res: bigint): void {
11017 if(!isWasmInitialized) {
11018 throw new Error("initializeWasm() must be awaited first!");
11020 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
11021 // debug statements here
11023 // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
11025 export function COption_u64Z_clone_ptr(arg: bigint): bigint {
11026 if(!isWasmInitialized) {
11027 throw new Error("initializeWasm() must be awaited first!");
11029 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
11030 return nativeResponseValue;
11032 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
11034 export function COption_u64Z_clone(orig: bigint): bigint {
11035 if(!isWasmInitialized) {
11036 throw new Error("initializeWasm() must be awaited first!");
11038 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
11039 return nativeResponseValue;
11041 // void CVec_BlindedPathZ_free(struct LDKCVec_BlindedPathZ _res);
11043 export function CVec_BlindedPathZ_free(_res: number): void {
11044 if(!isWasmInitialized) {
11045 throw new Error("initializeWasm() must be awaited first!");
11047 const nativeResponseValue = wasm.TS_CVec_BlindedPathZ_free(_res);
11048 // debug statements here
11050 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_ok(struct LDKRefund o);
11052 export function CResult_RefundBolt12ParseErrorZ_ok(o: bigint): bigint {
11053 if(!isWasmInitialized) {
11054 throw new Error("initializeWasm() must be awaited first!");
11056 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_ok(o);
11057 return nativeResponseValue;
11059 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
11061 export function CResult_RefundBolt12ParseErrorZ_err(e: bigint): bigint {
11062 if(!isWasmInitialized) {
11063 throw new Error("initializeWasm() must be awaited first!");
11065 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_err(e);
11066 return nativeResponseValue;
11068 // bool CResult_RefundBolt12ParseErrorZ_is_ok(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR o);
11070 export function CResult_RefundBolt12ParseErrorZ_is_ok(o: bigint): boolean {
11071 if(!isWasmInitialized) {
11072 throw new Error("initializeWasm() must be awaited first!");
11074 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_is_ok(o);
11075 return nativeResponseValue;
11077 // void CResult_RefundBolt12ParseErrorZ_free(struct LDKCResult_RefundBolt12ParseErrorZ _res);
11079 export function CResult_RefundBolt12ParseErrorZ_free(_res: bigint): void {
11080 if(!isWasmInitialized) {
11081 throw new Error("initializeWasm() must be awaited first!");
11083 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_free(_res);
11084 // debug statements here
11086 // uint64_t CResult_RefundBolt12ParseErrorZ_clone_ptr(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR arg);
11088 export function CResult_RefundBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
11089 if(!isWasmInitialized) {
11090 throw new Error("initializeWasm() must be awaited first!");
11092 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone_ptr(arg);
11093 return nativeResponseValue;
11095 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_clone(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR orig);
11097 export function CResult_RefundBolt12ParseErrorZ_clone(orig: bigint): bigint {
11098 if(!isWasmInitialized) {
11099 throw new Error("initializeWasm() must be awaited first!");
11101 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone(orig);
11102 return nativeResponseValue;
11104 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_ok(struct LDKRetry o);
11106 export function CResult_RetryDecodeErrorZ_ok(o: bigint): bigint {
11107 if(!isWasmInitialized) {
11108 throw new Error("initializeWasm() must be awaited first!");
11110 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_ok(o);
11111 return nativeResponseValue;
11113 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_err(struct LDKDecodeError e);
11115 export function CResult_RetryDecodeErrorZ_err(e: bigint): bigint {
11116 if(!isWasmInitialized) {
11117 throw new Error("initializeWasm() must be awaited first!");
11119 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_err(e);
11120 return nativeResponseValue;
11122 // bool CResult_RetryDecodeErrorZ_is_ok(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR o);
11124 export function CResult_RetryDecodeErrorZ_is_ok(o: bigint): boolean {
11125 if(!isWasmInitialized) {
11126 throw new Error("initializeWasm() must be awaited first!");
11128 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_is_ok(o);
11129 return nativeResponseValue;
11131 // void CResult_RetryDecodeErrorZ_free(struct LDKCResult_RetryDecodeErrorZ _res);
11133 export function CResult_RetryDecodeErrorZ_free(_res: bigint): void {
11134 if(!isWasmInitialized) {
11135 throw new Error("initializeWasm() must be awaited first!");
11137 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_free(_res);
11138 // debug statements here
11140 // uint64_t CResult_RetryDecodeErrorZ_clone_ptr(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR arg);
11142 export function CResult_RetryDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11143 if(!isWasmInitialized) {
11144 throw new Error("initializeWasm() must be awaited first!");
11146 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_clone_ptr(arg);
11147 return nativeResponseValue;
11149 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_clone(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR orig);
11151 export function CResult_RetryDecodeErrorZ_clone(orig: bigint): bigint {
11152 if(!isWasmInitialized) {
11153 throw new Error("initializeWasm() must be awaited first!");
11155 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_clone(orig);
11156 return nativeResponseValue;
11158 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
11160 export function CResult_NoneAPIErrorZ_ok(): bigint {
11161 if(!isWasmInitialized) {
11162 throw new Error("initializeWasm() must be awaited first!");
11164 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
11165 return nativeResponseValue;
11167 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
11169 export function CResult_NoneAPIErrorZ_err(e: bigint): bigint {
11170 if(!isWasmInitialized) {
11171 throw new Error("initializeWasm() must be awaited first!");
11173 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
11174 return nativeResponseValue;
11176 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
11178 export function CResult_NoneAPIErrorZ_is_ok(o: bigint): boolean {
11179 if(!isWasmInitialized) {
11180 throw new Error("initializeWasm() must be awaited first!");
11182 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
11183 return nativeResponseValue;
11185 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
11187 export function CResult_NoneAPIErrorZ_free(_res: bigint): void {
11188 if(!isWasmInitialized) {
11189 throw new Error("initializeWasm() must be awaited first!");
11191 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
11192 // debug statements here
11194 // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
11196 export function CResult_NoneAPIErrorZ_clone_ptr(arg: bigint): bigint {
11197 if(!isWasmInitialized) {
11198 throw new Error("initializeWasm() must be awaited first!");
11200 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
11201 return nativeResponseValue;
11203 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
11205 export function CResult_NoneAPIErrorZ_clone(orig: bigint): bigint {
11206 if(!isWasmInitialized) {
11207 throw new Error("initializeWasm() must be awaited first!");
11209 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
11210 return nativeResponseValue;
11212 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
11214 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
11215 if(!isWasmInitialized) {
11216 throw new Error("initializeWasm() must be awaited first!");
11218 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
11219 // debug statements here
11221 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
11223 export function CVec_APIErrorZ_free(_res: number): void {
11224 if(!isWasmInitialized) {
11225 throw new Error("initializeWasm() must be awaited first!");
11227 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
11228 // debug statements here
11230 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_some(struct LDKThirtyTwoBytes o);
11232 export function COption_ThirtyTwoBytesZ_some(o: number): bigint {
11233 if(!isWasmInitialized) {
11234 throw new Error("initializeWasm() must be awaited first!");
11236 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_some(o);
11237 return nativeResponseValue;
11239 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_none(void);
11241 export function COption_ThirtyTwoBytesZ_none(): bigint {
11242 if(!isWasmInitialized) {
11243 throw new Error("initializeWasm() must be awaited first!");
11245 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_none();
11246 return nativeResponseValue;
11248 // void COption_ThirtyTwoBytesZ_free(struct LDKCOption_ThirtyTwoBytesZ _res);
11250 export function COption_ThirtyTwoBytesZ_free(_res: bigint): void {
11251 if(!isWasmInitialized) {
11252 throw new Error("initializeWasm() must be awaited first!");
11254 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_free(_res);
11255 // debug statements here
11257 // uint64_t COption_ThirtyTwoBytesZ_clone_ptr(LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR arg);
11259 export function COption_ThirtyTwoBytesZ_clone_ptr(arg: bigint): bigint {
11260 if(!isWasmInitialized) {
11261 throw new Error("initializeWasm() must be awaited first!");
11263 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_clone_ptr(arg);
11264 return nativeResponseValue;
11266 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_clone(const struct LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR orig);
11268 export function COption_ThirtyTwoBytesZ_clone(orig: bigint): bigint {
11269 if(!isWasmInitialized) {
11270 throw new Error("initializeWasm() must be awaited first!");
11272 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_clone(orig);
11273 return nativeResponseValue;
11275 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
11277 export function CVec_u8Z_free(_res: number): void {
11278 if(!isWasmInitialized) {
11279 throw new Error("initializeWasm() must be awaited first!");
11281 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
11282 // debug statements here
11284 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_some(struct LDKCVec_u8Z o);
11286 export function COption_CVec_u8ZZ_some(o: number): bigint {
11287 if(!isWasmInitialized) {
11288 throw new Error("initializeWasm() must be awaited first!");
11290 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_some(o);
11291 return nativeResponseValue;
11293 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_none(void);
11295 export function COption_CVec_u8ZZ_none(): bigint {
11296 if(!isWasmInitialized) {
11297 throw new Error("initializeWasm() must be awaited first!");
11299 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_none();
11300 return nativeResponseValue;
11302 // void COption_CVec_u8ZZ_free(struct LDKCOption_CVec_u8ZZ _res);
11304 export function COption_CVec_u8ZZ_free(_res: bigint): void {
11305 if(!isWasmInitialized) {
11306 throw new Error("initializeWasm() must be awaited first!");
11308 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_free(_res);
11309 // debug statements here
11311 // uint64_t COption_CVec_u8ZZ_clone_ptr(LDKCOption_CVec_u8ZZ *NONNULL_PTR arg);
11313 export function COption_CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
11314 if(!isWasmInitialized) {
11315 throw new Error("initializeWasm() must be awaited first!");
11317 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone_ptr(arg);
11318 return nativeResponseValue;
11320 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_clone(const struct LDKCOption_CVec_u8ZZ *NONNULL_PTR orig);
11322 export function COption_CVec_u8ZZ_clone(orig: bigint): bigint {
11323 if(!isWasmInitialized) {
11324 throw new Error("initializeWasm() must be awaited first!");
11326 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone(orig);
11327 return nativeResponseValue;
11329 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_ok(struct LDKRecipientOnionFields o);
11331 export function CResult_RecipientOnionFieldsDecodeErrorZ_ok(o: bigint): bigint {
11332 if(!isWasmInitialized) {
11333 throw new Error("initializeWasm() must be awaited first!");
11335 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok(o);
11336 return nativeResponseValue;
11338 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_err(struct LDKDecodeError e);
11340 export function CResult_RecipientOnionFieldsDecodeErrorZ_err(e: bigint): bigint {
11341 if(!isWasmInitialized) {
11342 throw new Error("initializeWasm() must be awaited first!");
11344 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_err(e);
11345 return nativeResponseValue;
11347 // bool CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR o);
11349 export function CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o: bigint): boolean {
11350 if(!isWasmInitialized) {
11351 throw new Error("initializeWasm() must be awaited first!");
11353 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o);
11354 return nativeResponseValue;
11356 // void CResult_RecipientOnionFieldsDecodeErrorZ_free(struct LDKCResult_RecipientOnionFieldsDecodeErrorZ _res);
11358 export function CResult_RecipientOnionFieldsDecodeErrorZ_free(_res: bigint): void {
11359 if(!isWasmInitialized) {
11360 throw new Error("initializeWasm() must be awaited first!");
11362 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_free(_res);
11363 // debug statements here
11365 // uint64_t CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR arg);
11367 export function CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11368 if(!isWasmInitialized) {
11369 throw new Error("initializeWasm() must be awaited first!");
11371 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg);
11372 return nativeResponseValue;
11374 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_clone(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR orig);
11376 export function CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig: bigint): bigint {
11377 if(!isWasmInitialized) {
11378 throw new Error("initializeWasm() must be awaited first!");
11380 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig);
11381 return nativeResponseValue;
11383 // uint64_t C2Tuple_u64CVec_u8ZZ_clone_ptr(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR arg);
11385 export function C2Tuple_u64CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
11386 if(!isWasmInitialized) {
11387 throw new Error("initializeWasm() must be awaited first!");
11389 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_clone_ptr(arg);
11390 return nativeResponseValue;
11392 // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_clone(const struct LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR orig);
11394 export function C2Tuple_u64CVec_u8ZZ_clone(orig: bigint): bigint {
11395 if(!isWasmInitialized) {
11396 throw new Error("initializeWasm() must be awaited first!");
11398 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_clone(orig);
11399 return nativeResponseValue;
11401 // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_new(uint64_t a, struct LDKCVec_u8Z b);
11403 export function C2Tuple_u64CVec_u8ZZ_new(a: bigint, b: number): bigint {
11404 if(!isWasmInitialized) {
11405 throw new Error("initializeWasm() must be awaited first!");
11407 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_new(a, b);
11408 return nativeResponseValue;
11410 // void C2Tuple_u64CVec_u8ZZ_free(struct LDKC2Tuple_u64CVec_u8ZZ _res);
11412 export function C2Tuple_u64CVec_u8ZZ_free(_res: bigint): void {
11413 if(!isWasmInitialized) {
11414 throw new Error("initializeWasm() must be awaited first!");
11416 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_free(_res);
11417 // debug statements here
11419 // void CVec_C2Tuple_u64CVec_u8ZZZ_free(struct LDKCVec_C2Tuple_u64CVec_u8ZZZ _res);
11421 export function CVec_C2Tuple_u64CVec_u8ZZZ_free(_res: number): void {
11422 if(!isWasmInitialized) {
11423 throw new Error("initializeWasm() must be awaited first!");
11425 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u64CVec_u8ZZZ_free(_res);
11426 // debug statements here
11428 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_ok(struct LDKRecipientOnionFields o);
11430 export function CResult_RecipientOnionFieldsNoneZ_ok(o: bigint): bigint {
11431 if(!isWasmInitialized) {
11432 throw new Error("initializeWasm() must be awaited first!");
11434 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_ok(o);
11435 return nativeResponseValue;
11437 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_err(void);
11439 export function CResult_RecipientOnionFieldsNoneZ_err(): bigint {
11440 if(!isWasmInitialized) {
11441 throw new Error("initializeWasm() must be awaited first!");
11443 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_err();
11444 return nativeResponseValue;
11446 // bool CResult_RecipientOnionFieldsNoneZ_is_ok(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR o);
11448 export function CResult_RecipientOnionFieldsNoneZ_is_ok(o: bigint): boolean {
11449 if(!isWasmInitialized) {
11450 throw new Error("initializeWasm() must be awaited first!");
11452 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_is_ok(o);
11453 return nativeResponseValue;
11455 // void CResult_RecipientOnionFieldsNoneZ_free(struct LDKCResult_RecipientOnionFieldsNoneZ _res);
11457 export function CResult_RecipientOnionFieldsNoneZ_free(_res: bigint): void {
11458 if(!isWasmInitialized) {
11459 throw new Error("initializeWasm() must be awaited first!");
11461 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_free(_res);
11462 // debug statements here
11464 // uint64_t CResult_RecipientOnionFieldsNoneZ_clone_ptr(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR arg);
11466 export function CResult_RecipientOnionFieldsNoneZ_clone_ptr(arg: bigint): bigint {
11467 if(!isWasmInitialized) {
11468 throw new Error("initializeWasm() must be awaited first!");
11470 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_clone_ptr(arg);
11471 return nativeResponseValue;
11473 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_clone(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR orig);
11475 export function CResult_RecipientOnionFieldsNoneZ_clone(orig: bigint): bigint {
11476 if(!isWasmInitialized) {
11477 throw new Error("initializeWasm() must be awaited first!");
11479 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_clone(orig);
11480 return nativeResponseValue;
11482 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
11484 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
11485 if(!isWasmInitialized) {
11486 throw new Error("initializeWasm() must be awaited first!");
11488 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
11489 // debug statements here
11491 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_some(struct LDKCVec_ThirtyTwoBytesZ o);
11493 export function COption_CVec_ThirtyTwoBytesZZ_some(o: number): bigint {
11494 if(!isWasmInitialized) {
11495 throw new Error("initializeWasm() must be awaited first!");
11497 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_some(o);
11498 return nativeResponseValue;
11500 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_none(void);
11502 export function COption_CVec_ThirtyTwoBytesZZ_none(): bigint {
11503 if(!isWasmInitialized) {
11504 throw new Error("initializeWasm() must be awaited first!");
11506 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_none();
11507 return nativeResponseValue;
11509 // void COption_CVec_ThirtyTwoBytesZZ_free(struct LDKCOption_CVec_ThirtyTwoBytesZZ _res);
11511 export function COption_CVec_ThirtyTwoBytesZZ_free(_res: bigint): void {
11512 if(!isWasmInitialized) {
11513 throw new Error("initializeWasm() must be awaited first!");
11515 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_free(_res);
11516 // debug statements here
11518 // uint64_t COption_CVec_ThirtyTwoBytesZZ_clone_ptr(LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR arg);
11520 export function COption_CVec_ThirtyTwoBytesZZ_clone_ptr(arg: bigint): bigint {
11521 if(!isWasmInitialized) {
11522 throw new Error("initializeWasm() must be awaited first!");
11524 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_clone_ptr(arg);
11525 return nativeResponseValue;
11527 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_clone(const struct LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR orig);
11529 export function COption_CVec_ThirtyTwoBytesZZ_clone(orig: bigint): bigint {
11530 if(!isWasmInitialized) {
11531 throw new Error("initializeWasm() must be awaited first!");
11533 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_clone(orig);
11534 return nativeResponseValue;
11536 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_ok(struct LDKThirtyTwoBytes o);
11538 export function CResult_ThirtyTwoBytesNoneZ_ok(o: number): bigint {
11539 if(!isWasmInitialized) {
11540 throw new Error("initializeWasm() must be awaited first!");
11542 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_ok(o);
11543 return nativeResponseValue;
11545 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_err(void);
11547 export function CResult_ThirtyTwoBytesNoneZ_err(): bigint {
11548 if(!isWasmInitialized) {
11549 throw new Error("initializeWasm() must be awaited first!");
11551 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_err();
11552 return nativeResponseValue;
11554 // bool CResult_ThirtyTwoBytesNoneZ_is_ok(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR o);
11556 export function CResult_ThirtyTwoBytesNoneZ_is_ok(o: bigint): boolean {
11557 if(!isWasmInitialized) {
11558 throw new Error("initializeWasm() must be awaited first!");
11560 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_is_ok(o);
11561 return nativeResponseValue;
11563 // void CResult_ThirtyTwoBytesNoneZ_free(struct LDKCResult_ThirtyTwoBytesNoneZ _res);
11565 export function CResult_ThirtyTwoBytesNoneZ_free(_res: bigint): void {
11566 if(!isWasmInitialized) {
11567 throw new Error("initializeWasm() must be awaited first!");
11569 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_free(_res);
11570 // debug statements here
11572 // uint64_t CResult_ThirtyTwoBytesNoneZ_clone_ptr(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR arg);
11574 export function CResult_ThirtyTwoBytesNoneZ_clone_ptr(arg: bigint): bigint {
11575 if(!isWasmInitialized) {
11576 throw new Error("initializeWasm() must be awaited first!");
11578 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_clone_ptr(arg);
11579 return nativeResponseValue;
11581 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_clone(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR orig);
11583 export function CResult_ThirtyTwoBytesNoneZ_clone(orig: bigint): bigint {
11584 if(!isWasmInitialized) {
11585 throw new Error("initializeWasm() must be awaited first!");
11587 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_clone(orig);
11588 return nativeResponseValue;
11590 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_ok(struct LDKBlindedPayInfo o);
11592 export function CResult_BlindedPayInfoDecodeErrorZ_ok(o: bigint): bigint {
11593 if(!isWasmInitialized) {
11594 throw new Error("initializeWasm() must be awaited first!");
11596 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_ok(o);
11597 return nativeResponseValue;
11599 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_err(struct LDKDecodeError e);
11601 export function CResult_BlindedPayInfoDecodeErrorZ_err(e: bigint): bigint {
11602 if(!isWasmInitialized) {
11603 throw new Error("initializeWasm() must be awaited first!");
11605 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_err(e);
11606 return nativeResponseValue;
11608 // bool CResult_BlindedPayInfoDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR o);
11610 export function CResult_BlindedPayInfoDecodeErrorZ_is_ok(o: bigint): boolean {
11611 if(!isWasmInitialized) {
11612 throw new Error("initializeWasm() must be awaited first!");
11614 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok(o);
11615 return nativeResponseValue;
11617 // void CResult_BlindedPayInfoDecodeErrorZ_free(struct LDKCResult_BlindedPayInfoDecodeErrorZ _res);
11619 export function CResult_BlindedPayInfoDecodeErrorZ_free(_res: bigint): void {
11620 if(!isWasmInitialized) {
11621 throw new Error("initializeWasm() must be awaited first!");
11623 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_free(_res);
11624 // debug statements here
11626 // uint64_t CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR arg);
11628 export function CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11629 if(!isWasmInitialized) {
11630 throw new Error("initializeWasm() must be awaited first!");
11632 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg);
11633 return nativeResponseValue;
11635 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_clone(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR orig);
11637 export function CResult_BlindedPayInfoDecodeErrorZ_clone(orig: bigint): bigint {
11638 if(!isWasmInitialized) {
11639 throw new Error("initializeWasm() must be awaited first!");
11641 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone(orig);
11642 return nativeResponseValue;
11644 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
11646 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11647 if(!isWasmInitialized) {
11648 throw new Error("initializeWasm() must be awaited first!");
11650 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
11651 return nativeResponseValue;
11653 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11655 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11656 if(!isWasmInitialized) {
11657 throw new Error("initializeWasm() must be awaited first!");
11659 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
11660 return nativeResponseValue;
11662 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11664 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11665 if(!isWasmInitialized) {
11666 throw new Error("initializeWasm() must be awaited first!");
11668 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
11669 return nativeResponseValue;
11671 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
11673 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11674 if(!isWasmInitialized) {
11675 throw new Error("initializeWasm() must be awaited first!");
11677 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
11678 // debug statements here
11680 // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11682 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11683 if(!isWasmInitialized) {
11684 throw new Error("initializeWasm() must be awaited first!");
11686 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11687 return nativeResponseValue;
11689 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11691 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11692 if(!isWasmInitialized) {
11693 throw new Error("initializeWasm() must be awaited first!");
11695 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
11696 return nativeResponseValue;
11698 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
11700 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11701 if(!isWasmInitialized) {
11702 throw new Error("initializeWasm() must be awaited first!");
11704 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
11705 return nativeResponseValue;
11707 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11709 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11710 if(!isWasmInitialized) {
11711 throw new Error("initializeWasm() must be awaited first!");
11713 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
11714 return nativeResponseValue;
11716 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11718 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11719 if(!isWasmInitialized) {
11720 throw new Error("initializeWasm() must be awaited first!");
11722 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
11723 return nativeResponseValue;
11725 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
11727 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11728 if(!isWasmInitialized) {
11729 throw new Error("initializeWasm() must be awaited first!");
11731 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
11732 // debug statements here
11734 // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11736 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11737 if(!isWasmInitialized) {
11738 throw new Error("initializeWasm() must be awaited first!");
11740 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11741 return nativeResponseValue;
11743 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11745 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11746 if(!isWasmInitialized) {
11747 throw new Error("initializeWasm() must be awaited first!");
11749 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
11750 return nativeResponseValue;
11752 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
11754 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
11755 if(!isWasmInitialized) {
11756 throw new Error("initializeWasm() must be awaited first!");
11758 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
11759 return nativeResponseValue;
11761 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
11763 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
11764 if(!isWasmInitialized) {
11765 throw new Error("initializeWasm() must be awaited first!");
11767 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
11768 return nativeResponseValue;
11770 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
11772 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
11773 if(!isWasmInitialized) {
11774 throw new Error("initializeWasm() must be awaited first!");
11776 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
11777 return nativeResponseValue;
11779 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
11781 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
11782 if(!isWasmInitialized) {
11783 throw new Error("initializeWasm() must be awaited first!");
11785 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
11786 // debug statements here
11788 // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
11790 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11791 if(!isWasmInitialized) {
11792 throw new Error("initializeWasm() must be awaited first!");
11794 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
11795 return nativeResponseValue;
11797 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11799 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
11800 if(!isWasmInitialized) {
11801 throw new Error("initializeWasm() must be awaited first!");
11803 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
11804 return nativeResponseValue;
11806 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
11808 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
11809 if(!isWasmInitialized) {
11810 throw new Error("initializeWasm() must be awaited first!");
11812 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
11813 // debug statements here
11815 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
11817 export function CVec_TxOutZ_free(_res: number): void {
11818 if(!isWasmInitialized) {
11819 throw new Error("initializeWasm() must be awaited first!");
11821 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
11822 // debug statements here
11824 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
11826 export function COption_u32Z_some(o: number): bigint {
11827 if(!isWasmInitialized) {
11828 throw new Error("initializeWasm() must be awaited first!");
11830 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
11831 return nativeResponseValue;
11833 // struct LDKCOption_u32Z COption_u32Z_none(void);
11835 export function COption_u32Z_none(): bigint {
11836 if(!isWasmInitialized) {
11837 throw new Error("initializeWasm() must be awaited first!");
11839 const nativeResponseValue = wasm.TS_COption_u32Z_none();
11840 return nativeResponseValue;
11842 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
11844 export function COption_u32Z_free(_res: bigint): void {
11845 if(!isWasmInitialized) {
11846 throw new Error("initializeWasm() must be awaited first!");
11848 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
11849 // debug statements here
11851 // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
11853 export function COption_u32Z_clone_ptr(arg: bigint): bigint {
11854 if(!isWasmInitialized) {
11855 throw new Error("initializeWasm() must be awaited first!");
11857 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
11858 return nativeResponseValue;
11860 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
11862 export function COption_u32Z_clone(orig: bigint): bigint {
11863 if(!isWasmInitialized) {
11864 throw new Error("initializeWasm() must be awaited first!");
11866 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
11867 return nativeResponseValue;
11869 // uint64_t C2Tuple_CVec_u8ZusizeZ_clone_ptr(LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR arg);
11871 export function C2Tuple_CVec_u8ZusizeZ_clone_ptr(arg: bigint): bigint {
11872 if(!isWasmInitialized) {
11873 throw new Error("initializeWasm() must be awaited first!");
11875 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_clone_ptr(arg);
11876 return nativeResponseValue;
11878 // struct LDKC2Tuple_CVec_u8ZusizeZ C2Tuple_CVec_u8ZusizeZ_clone(const struct LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR orig);
11880 export function C2Tuple_CVec_u8ZusizeZ_clone(orig: bigint): bigint {
11881 if(!isWasmInitialized) {
11882 throw new Error("initializeWasm() must be awaited first!");
11884 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_clone(orig);
11885 return nativeResponseValue;
11887 // struct LDKC2Tuple_CVec_u8ZusizeZ C2Tuple_CVec_u8ZusizeZ_new(struct LDKCVec_u8Z a, uintptr_t b);
11889 export function C2Tuple_CVec_u8ZusizeZ_new(a: number, b: number): bigint {
11890 if(!isWasmInitialized) {
11891 throw new Error("initializeWasm() must be awaited first!");
11893 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_new(a, b);
11894 return nativeResponseValue;
11896 // void C2Tuple_CVec_u8ZusizeZ_free(struct LDKC2Tuple_CVec_u8ZusizeZ _res);
11898 export function C2Tuple_CVec_u8ZusizeZ_free(_res: bigint): void {
11899 if(!isWasmInitialized) {
11900 throw new Error("initializeWasm() must be awaited first!");
11902 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8ZusizeZ_free(_res);
11903 // debug statements here
11905 // struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok(struct LDKC2Tuple_CVec_u8ZusizeZ o);
11907 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok(o: bigint): bigint {
11908 if(!isWasmInitialized) {
11909 throw new Error("initializeWasm() must be awaited first!");
11911 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok(o);
11912 return nativeResponseValue;
11914 // struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err(void);
11916 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err(): bigint {
11917 if(!isWasmInitialized) {
11918 throw new Error("initializeWasm() must be awaited first!");
11920 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err();
11921 return nativeResponseValue;
11923 // bool CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok(const struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR o);
11925 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok(o: bigint): boolean {
11926 if(!isWasmInitialized) {
11927 throw new Error("initializeWasm() must be awaited first!");
11929 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok(o);
11930 return nativeResponseValue;
11932 // void CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ _res);
11934 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(_res: bigint): void {
11935 if(!isWasmInitialized) {
11936 throw new Error("initializeWasm() must be awaited first!");
11938 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(_res);
11939 // debug statements here
11941 // uint64_t CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR arg);
11943 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(arg: bigint): bigint {
11944 if(!isWasmInitialized) {
11945 throw new Error("initializeWasm() must be awaited first!");
11947 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(arg);
11948 return nativeResponseValue;
11950 // struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(const struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR orig);
11952 export function CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(orig: bigint): bigint {
11953 if(!isWasmInitialized) {
11954 throw new Error("initializeWasm() must be awaited first!");
11956 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(orig);
11957 return nativeResponseValue;
11959 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_ok(struct LDKChannelDerivationParameters o);
11961 export function CResult_ChannelDerivationParametersDecodeErrorZ_ok(o: bigint): bigint {
11962 if(!isWasmInitialized) {
11963 throw new Error("initializeWasm() must be awaited first!");
11965 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_ok(o);
11966 return nativeResponseValue;
11968 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_err(struct LDKDecodeError e);
11970 export function CResult_ChannelDerivationParametersDecodeErrorZ_err(e: bigint): bigint {
11971 if(!isWasmInitialized) {
11972 throw new Error("initializeWasm() must be awaited first!");
11974 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_err(e);
11975 return nativeResponseValue;
11977 // bool CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR o);
11979 export function CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(o: bigint): boolean {
11980 if(!isWasmInitialized) {
11981 throw new Error("initializeWasm() must be awaited first!");
11983 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(o);
11984 return nativeResponseValue;
11986 // void CResult_ChannelDerivationParametersDecodeErrorZ_free(struct LDKCResult_ChannelDerivationParametersDecodeErrorZ _res);
11988 export function CResult_ChannelDerivationParametersDecodeErrorZ_free(_res: bigint): void {
11989 if(!isWasmInitialized) {
11990 throw new Error("initializeWasm() must be awaited first!");
11992 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_free(_res);
11993 // debug statements here
11995 // uint64_t CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR arg);
11997 export function CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11998 if(!isWasmInitialized) {
11999 throw new Error("initializeWasm() must be awaited first!");
12001 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(arg);
12002 return nativeResponseValue;
12004 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR orig);
12006 export function CResult_ChannelDerivationParametersDecodeErrorZ_clone(orig: bigint): bigint {
12007 if(!isWasmInitialized) {
12008 throw new Error("initializeWasm() must be awaited first!");
12010 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone(orig);
12011 return nativeResponseValue;
12013 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_ok(struct LDKHTLCDescriptor o);
12015 export function CResult_HTLCDescriptorDecodeErrorZ_ok(o: bigint): bigint {
12016 if(!isWasmInitialized) {
12017 throw new Error("initializeWasm() must be awaited first!");
12019 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_ok(o);
12020 return nativeResponseValue;
12022 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
12024 export function CResult_HTLCDescriptorDecodeErrorZ_err(e: bigint): bigint {
12025 if(!isWasmInitialized) {
12026 throw new Error("initializeWasm() must be awaited first!");
12028 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_err(e);
12029 return nativeResponseValue;
12031 // bool CResult_HTLCDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR o);
12033 export function CResult_HTLCDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
12034 if(!isWasmInitialized) {
12035 throw new Error("initializeWasm() must be awaited first!");
12037 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_is_ok(o);
12038 return nativeResponseValue;
12040 // void CResult_HTLCDescriptorDecodeErrorZ_free(struct LDKCResult_HTLCDescriptorDecodeErrorZ _res);
12042 export function CResult_HTLCDescriptorDecodeErrorZ_free(_res: bigint): void {
12043 if(!isWasmInitialized) {
12044 throw new Error("initializeWasm() must be awaited first!");
12046 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_free(_res);
12047 // debug statements here
12049 // uint64_t CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR arg);
12051 export function CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12052 if(!isWasmInitialized) {
12053 throw new Error("initializeWasm() must be awaited first!");
12055 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(arg);
12056 return nativeResponseValue;
12058 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_clone(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR orig);
12060 export function CResult_HTLCDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
12061 if(!isWasmInitialized) {
12062 throw new Error("initializeWasm() must be awaited first!");
12064 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_clone(orig);
12065 return nativeResponseValue;
12067 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
12069 export function CResult_NoneNoneZ_ok(): bigint {
12070 if(!isWasmInitialized) {
12071 throw new Error("initializeWasm() must be awaited first!");
12073 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
12074 return nativeResponseValue;
12076 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
12078 export function CResult_NoneNoneZ_err(): bigint {
12079 if(!isWasmInitialized) {
12080 throw new Error("initializeWasm() must be awaited first!");
12082 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
12083 return nativeResponseValue;
12085 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
12087 export function CResult_NoneNoneZ_is_ok(o: bigint): boolean {
12088 if(!isWasmInitialized) {
12089 throw new Error("initializeWasm() must be awaited first!");
12091 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
12092 return nativeResponseValue;
12094 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
12096 export function CResult_NoneNoneZ_free(_res: bigint): void {
12097 if(!isWasmInitialized) {
12098 throw new Error("initializeWasm() must be awaited first!");
12100 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
12101 // debug statements here
12103 // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
12105 export function CResult_NoneNoneZ_clone_ptr(arg: bigint): bigint {
12106 if(!isWasmInitialized) {
12107 throw new Error("initializeWasm() must be awaited first!");
12109 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
12110 return nativeResponseValue;
12112 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
12114 export function CResult_NoneNoneZ_clone(orig: bigint): bigint {
12115 if(!isWasmInitialized) {
12116 throw new Error("initializeWasm() must be awaited first!");
12118 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
12119 return nativeResponseValue;
12121 // void CVec_ECDSASignatureZ_free(struct LDKCVec_ECDSASignatureZ _res);
12123 export function CVec_ECDSASignatureZ_free(_res: number): void {
12124 if(!isWasmInitialized) {
12125 throw new Error("initializeWasm() must be awaited first!");
12127 const nativeResponseValue = wasm.TS_CVec_ECDSASignatureZ_free(_res);
12128 // debug statements here
12130 // uint64_t C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR arg);
12132 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(arg: bigint): bigint {
12133 if(!isWasmInitialized) {
12134 throw new Error("initializeWasm() must be awaited first!");
12136 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(arg);
12137 return nativeResponseValue;
12139 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(const struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR orig);
12141 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(orig: bigint): bigint {
12142 if(!isWasmInitialized) {
12143 throw new Error("initializeWasm() must be awaited first!");
12145 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(orig);
12146 return nativeResponseValue;
12148 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(struct LDKECDSASignature a, struct LDKCVec_ECDSASignatureZ b);
12150 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(a: number, b: number): bigint {
12151 if(!isWasmInitialized) {
12152 throw new Error("initializeWasm() must be awaited first!");
12154 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(a, b);
12155 return nativeResponseValue;
12157 // void C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ _res);
12159 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(_res: bigint): void {
12160 if(!isWasmInitialized) {
12161 throw new Error("initializeWasm() must be awaited first!");
12163 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(_res);
12164 // debug statements here
12166 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ o);
12168 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(o: bigint): bigint {
12169 if(!isWasmInitialized) {
12170 throw new Error("initializeWasm() must be awaited first!");
12172 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(o);
12173 return nativeResponseValue;
12175 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err(void);
12177 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err(): bigint {
12178 if(!isWasmInitialized) {
12179 throw new Error("initializeWasm() must be awaited first!");
12181 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err();
12182 return nativeResponseValue;
12184 // bool CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR o);
12186 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(o: bigint): boolean {
12187 if(!isWasmInitialized) {
12188 throw new Error("initializeWasm() must be awaited first!");
12190 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(o);
12191 return nativeResponseValue;
12193 // void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ _res);
12195 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(_res: bigint): void {
12196 if(!isWasmInitialized) {
12197 throw new Error("initializeWasm() must be awaited first!");
12199 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(_res);
12200 // debug statements here
12202 // uint64_t CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR arg);
12204 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(arg: bigint): bigint {
12205 if(!isWasmInitialized) {
12206 throw new Error("initializeWasm() must be awaited first!");
12208 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(arg);
12209 return nativeResponseValue;
12211 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR orig);
12213 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(orig: bigint): bigint {
12214 if(!isWasmInitialized) {
12215 throw new Error("initializeWasm() must be awaited first!");
12217 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(orig);
12218 return nativeResponseValue;
12220 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_ok(struct LDKECDSASignature o);
12222 export function CResult_ECDSASignatureNoneZ_ok(o: number): bigint {
12223 if(!isWasmInitialized) {
12224 throw new Error("initializeWasm() must be awaited first!");
12226 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_ok(o);
12227 return nativeResponseValue;
12229 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_err(void);
12231 export function CResult_ECDSASignatureNoneZ_err(): bigint {
12232 if(!isWasmInitialized) {
12233 throw new Error("initializeWasm() must be awaited first!");
12235 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_err();
12236 return nativeResponseValue;
12238 // bool CResult_ECDSASignatureNoneZ_is_ok(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR o);
12240 export function CResult_ECDSASignatureNoneZ_is_ok(o: bigint): boolean {
12241 if(!isWasmInitialized) {
12242 throw new Error("initializeWasm() must be awaited first!");
12244 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_is_ok(o);
12245 return nativeResponseValue;
12247 // void CResult_ECDSASignatureNoneZ_free(struct LDKCResult_ECDSASignatureNoneZ _res);
12249 export function CResult_ECDSASignatureNoneZ_free(_res: bigint): void {
12250 if(!isWasmInitialized) {
12251 throw new Error("initializeWasm() must be awaited first!");
12253 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_free(_res);
12254 // debug statements here
12256 // uint64_t CResult_ECDSASignatureNoneZ_clone_ptr(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR arg);
12258 export function CResult_ECDSASignatureNoneZ_clone_ptr(arg: bigint): bigint {
12259 if(!isWasmInitialized) {
12260 throw new Error("initializeWasm() must be awaited first!");
12262 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_clone_ptr(arg);
12263 return nativeResponseValue;
12265 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_clone(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR orig);
12267 export function CResult_ECDSASignatureNoneZ_clone(orig: bigint): bigint {
12268 if(!isWasmInitialized) {
12269 throw new Error("initializeWasm() must be awaited first!");
12271 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_clone(orig);
12272 return nativeResponseValue;
12274 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_ok(struct LDKPublicKey o);
12276 export function CResult_PublicKeyNoneZ_ok(o: number): bigint {
12277 if(!isWasmInitialized) {
12278 throw new Error("initializeWasm() must be awaited first!");
12280 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_ok(o);
12281 return nativeResponseValue;
12283 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_err(void);
12285 export function CResult_PublicKeyNoneZ_err(): bigint {
12286 if(!isWasmInitialized) {
12287 throw new Error("initializeWasm() must be awaited first!");
12289 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_err();
12290 return nativeResponseValue;
12292 // bool CResult_PublicKeyNoneZ_is_ok(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR o);
12294 export function CResult_PublicKeyNoneZ_is_ok(o: bigint): boolean {
12295 if(!isWasmInitialized) {
12296 throw new Error("initializeWasm() must be awaited first!");
12298 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_is_ok(o);
12299 return nativeResponseValue;
12301 // void CResult_PublicKeyNoneZ_free(struct LDKCResult_PublicKeyNoneZ _res);
12303 export function CResult_PublicKeyNoneZ_free(_res: bigint): void {
12304 if(!isWasmInitialized) {
12305 throw new Error("initializeWasm() must be awaited first!");
12307 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_free(_res);
12308 // debug statements here
12310 // uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg);
12312 export function CResult_PublicKeyNoneZ_clone_ptr(arg: bigint): bigint {
12313 if(!isWasmInitialized) {
12314 throw new Error("initializeWasm() must be awaited first!");
12316 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone_ptr(arg);
12317 return nativeResponseValue;
12319 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_clone(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR orig);
12321 export function CResult_PublicKeyNoneZ_clone(orig: bigint): bigint {
12322 if(!isWasmInitialized) {
12323 throw new Error("initializeWasm() must be awaited first!");
12325 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone(orig);
12326 return nativeResponseValue;
12328 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_some(struct LDKBigEndianScalar o);
12330 export function COption_BigEndianScalarZ_some(o: bigint): bigint {
12331 if(!isWasmInitialized) {
12332 throw new Error("initializeWasm() must be awaited first!");
12334 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_some(o);
12335 return nativeResponseValue;
12337 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_none(void);
12339 export function COption_BigEndianScalarZ_none(): bigint {
12340 if(!isWasmInitialized) {
12341 throw new Error("initializeWasm() must be awaited first!");
12343 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_none();
12344 return nativeResponseValue;
12346 // void COption_BigEndianScalarZ_free(struct LDKCOption_BigEndianScalarZ _res);
12348 export function COption_BigEndianScalarZ_free(_res: bigint): void {
12349 if(!isWasmInitialized) {
12350 throw new Error("initializeWasm() must be awaited first!");
12352 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_free(_res);
12353 // debug statements here
12355 // uint64_t COption_BigEndianScalarZ_clone_ptr(LDKCOption_BigEndianScalarZ *NONNULL_PTR arg);
12357 export function COption_BigEndianScalarZ_clone_ptr(arg: bigint): bigint {
12358 if(!isWasmInitialized) {
12359 throw new Error("initializeWasm() must be awaited first!");
12361 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_clone_ptr(arg);
12362 return nativeResponseValue;
12364 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_clone(const struct LDKCOption_BigEndianScalarZ *NONNULL_PTR orig);
12366 export function COption_BigEndianScalarZ_clone(orig: bigint): bigint {
12367 if(!isWasmInitialized) {
12368 throw new Error("initializeWasm() must be awaited first!");
12370 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_clone(orig);
12371 return nativeResponseValue;
12373 // void CVec_U5Z_free(struct LDKCVec_U5Z _res);
12375 export function CVec_U5Z_free(_res: number): void {
12376 if(!isWasmInitialized) {
12377 throw new Error("initializeWasm() must be awaited first!");
12379 const nativeResponseValue = wasm.TS_CVec_U5Z_free(_res);
12380 // debug statements here
12382 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
12384 export function CResult_RecoverableSignatureNoneZ_ok(o: number): bigint {
12385 if(!isWasmInitialized) {
12386 throw new Error("initializeWasm() must be awaited first!");
12388 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
12389 return nativeResponseValue;
12391 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
12393 export function CResult_RecoverableSignatureNoneZ_err(): bigint {
12394 if(!isWasmInitialized) {
12395 throw new Error("initializeWasm() must be awaited first!");
12397 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
12398 return nativeResponseValue;
12400 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
12402 export function CResult_RecoverableSignatureNoneZ_is_ok(o: bigint): boolean {
12403 if(!isWasmInitialized) {
12404 throw new Error("initializeWasm() must be awaited first!");
12406 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
12407 return nativeResponseValue;
12409 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
12411 export function CResult_RecoverableSignatureNoneZ_free(_res: bigint): void {
12412 if(!isWasmInitialized) {
12413 throw new Error("initializeWasm() must be awaited first!");
12415 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
12416 // debug statements here
12418 // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
12420 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: bigint): bigint {
12421 if(!isWasmInitialized) {
12422 throw new Error("initializeWasm() must be awaited first!");
12424 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
12425 return nativeResponseValue;
12427 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
12429 export function CResult_RecoverableSignatureNoneZ_clone(orig: bigint): bigint {
12430 if(!isWasmInitialized) {
12431 throw new Error("initializeWasm() must be awaited first!");
12433 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
12434 return nativeResponseValue;
12436 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_ok(struct LDKSchnorrSignature o);
12438 export function CResult_SchnorrSignatureNoneZ_ok(o: number): bigint {
12439 if(!isWasmInitialized) {
12440 throw new Error("initializeWasm() must be awaited first!");
12442 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_ok(o);
12443 return nativeResponseValue;
12445 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_err(void);
12447 export function CResult_SchnorrSignatureNoneZ_err(): bigint {
12448 if(!isWasmInitialized) {
12449 throw new Error("initializeWasm() must be awaited first!");
12451 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_err();
12452 return nativeResponseValue;
12454 // bool CResult_SchnorrSignatureNoneZ_is_ok(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR o);
12456 export function CResult_SchnorrSignatureNoneZ_is_ok(o: bigint): boolean {
12457 if(!isWasmInitialized) {
12458 throw new Error("initializeWasm() must be awaited first!");
12460 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_is_ok(o);
12461 return nativeResponseValue;
12463 // void CResult_SchnorrSignatureNoneZ_free(struct LDKCResult_SchnorrSignatureNoneZ _res);
12465 export function CResult_SchnorrSignatureNoneZ_free(_res: bigint): void {
12466 if(!isWasmInitialized) {
12467 throw new Error("initializeWasm() must be awaited first!");
12469 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_free(_res);
12470 // debug statements here
12472 // uint64_t CResult_SchnorrSignatureNoneZ_clone_ptr(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR arg);
12474 export function CResult_SchnorrSignatureNoneZ_clone_ptr(arg: bigint): bigint {
12475 if(!isWasmInitialized) {
12476 throw new Error("initializeWasm() must be awaited first!");
12478 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_clone_ptr(arg);
12479 return nativeResponseValue;
12481 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_clone(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR orig);
12483 export function CResult_SchnorrSignatureNoneZ_clone(orig: bigint): bigint {
12484 if(!isWasmInitialized) {
12485 throw new Error("initializeWasm() must be awaited first!");
12487 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_clone(orig);
12488 return nativeResponseValue;
12490 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(struct LDKWriteableEcdsaChannelSigner o);
12492 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o: bigint): bigint {
12493 if(!isWasmInitialized) {
12494 throw new Error("initializeWasm() must be awaited first!");
12496 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o);
12497 return nativeResponseValue;
12499 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(struct LDKDecodeError e);
12501 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e: bigint): bigint {
12502 if(!isWasmInitialized) {
12503 throw new Error("initializeWasm() must be awaited first!");
12505 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e);
12506 return nativeResponseValue;
12508 // bool CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR o);
12510 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o: bigint): boolean {
12511 if(!isWasmInitialized) {
12512 throw new Error("initializeWasm() must be awaited first!");
12514 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o);
12515 return nativeResponseValue;
12517 // void CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ _res);
12519 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res: bigint): void {
12520 if(!isWasmInitialized) {
12521 throw new Error("initializeWasm() must be awaited first!");
12523 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res);
12524 // debug statements here
12526 // uint64_t CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR arg);
12528 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12529 if(!isWasmInitialized) {
12530 throw new Error("initializeWasm() must be awaited first!");
12532 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg);
12533 return nativeResponseValue;
12535 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR orig);
12537 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig: bigint): bigint {
12538 if(!isWasmInitialized) {
12539 throw new Error("initializeWasm() must be awaited first!");
12541 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig);
12542 return nativeResponseValue;
12544 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_ok(struct LDKCVec_u8Z o);
12546 export function CResult_CVec_u8ZNoneZ_ok(o: number): bigint {
12547 if(!isWasmInitialized) {
12548 throw new Error("initializeWasm() must be awaited first!");
12550 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_ok(o);
12551 return nativeResponseValue;
12553 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_err(void);
12555 export function CResult_CVec_u8ZNoneZ_err(): bigint {
12556 if(!isWasmInitialized) {
12557 throw new Error("initializeWasm() must be awaited first!");
12559 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_err();
12560 return nativeResponseValue;
12562 // bool CResult_CVec_u8ZNoneZ_is_ok(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR o);
12564 export function CResult_CVec_u8ZNoneZ_is_ok(o: bigint): boolean {
12565 if(!isWasmInitialized) {
12566 throw new Error("initializeWasm() must be awaited first!");
12568 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_is_ok(o);
12569 return nativeResponseValue;
12571 // void CResult_CVec_u8ZNoneZ_free(struct LDKCResult_CVec_u8ZNoneZ _res);
12573 export function CResult_CVec_u8ZNoneZ_free(_res: bigint): void {
12574 if(!isWasmInitialized) {
12575 throw new Error("initializeWasm() must be awaited first!");
12577 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_free(_res);
12578 // debug statements here
12580 // uint64_t CResult_CVec_u8ZNoneZ_clone_ptr(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR arg);
12582 export function CResult_CVec_u8ZNoneZ_clone_ptr(arg: bigint): bigint {
12583 if(!isWasmInitialized) {
12584 throw new Error("initializeWasm() must be awaited first!");
12586 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_clone_ptr(arg);
12587 return nativeResponseValue;
12589 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_clone(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR orig);
12591 export function CResult_CVec_u8ZNoneZ_clone(orig: bigint): bigint {
12592 if(!isWasmInitialized) {
12593 throw new Error("initializeWasm() must be awaited first!");
12595 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_clone(orig);
12596 return nativeResponseValue;
12598 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_ok(struct LDKShutdownScript o);
12600 export function CResult_ShutdownScriptNoneZ_ok(o: bigint): bigint {
12601 if(!isWasmInitialized) {
12602 throw new Error("initializeWasm() must be awaited first!");
12604 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_ok(o);
12605 return nativeResponseValue;
12607 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_err(void);
12609 export function CResult_ShutdownScriptNoneZ_err(): bigint {
12610 if(!isWasmInitialized) {
12611 throw new Error("initializeWasm() must be awaited first!");
12613 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_err();
12614 return nativeResponseValue;
12616 // bool CResult_ShutdownScriptNoneZ_is_ok(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR o);
12618 export function CResult_ShutdownScriptNoneZ_is_ok(o: bigint): boolean {
12619 if(!isWasmInitialized) {
12620 throw new Error("initializeWasm() must be awaited first!");
12622 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_is_ok(o);
12623 return nativeResponseValue;
12625 // void CResult_ShutdownScriptNoneZ_free(struct LDKCResult_ShutdownScriptNoneZ _res);
12627 export function CResult_ShutdownScriptNoneZ_free(_res: bigint): void {
12628 if(!isWasmInitialized) {
12629 throw new Error("initializeWasm() must be awaited first!");
12631 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_free(_res);
12632 // debug statements here
12634 // uint64_t CResult_ShutdownScriptNoneZ_clone_ptr(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR arg);
12636 export function CResult_ShutdownScriptNoneZ_clone_ptr(arg: bigint): bigint {
12637 if(!isWasmInitialized) {
12638 throw new Error("initializeWasm() must be awaited first!");
12640 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone_ptr(arg);
12641 return nativeResponseValue;
12643 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_clone(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR orig);
12645 export function CResult_ShutdownScriptNoneZ_clone(orig: bigint): bigint {
12646 if(!isWasmInitialized) {
12647 throw new Error("initializeWasm() must be awaited first!");
12649 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone(orig);
12650 return nativeResponseValue;
12652 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
12654 export function COption_u16Z_some(o: number): bigint {
12655 if(!isWasmInitialized) {
12656 throw new Error("initializeWasm() must be awaited first!");
12658 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
12659 return nativeResponseValue;
12661 // struct LDKCOption_u16Z COption_u16Z_none(void);
12663 export function COption_u16Z_none(): bigint {
12664 if(!isWasmInitialized) {
12665 throw new Error("initializeWasm() must be awaited first!");
12667 const nativeResponseValue = wasm.TS_COption_u16Z_none();
12668 return nativeResponseValue;
12670 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
12672 export function COption_u16Z_free(_res: bigint): void {
12673 if(!isWasmInitialized) {
12674 throw new Error("initializeWasm() must be awaited first!");
12676 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
12677 // debug statements here
12679 // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
12681 export function COption_u16Z_clone_ptr(arg: bigint): bigint {
12682 if(!isWasmInitialized) {
12683 throw new Error("initializeWasm() must be awaited first!");
12685 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
12686 return nativeResponseValue;
12688 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
12690 export function COption_u16Z_clone(orig: bigint): bigint {
12691 if(!isWasmInitialized) {
12692 throw new Error("initializeWasm() must be awaited first!");
12694 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
12695 return nativeResponseValue;
12697 // struct LDKCOption_boolZ COption_boolZ_some(bool o);
12699 export function COption_boolZ_some(o: boolean): bigint {
12700 if(!isWasmInitialized) {
12701 throw new Error("initializeWasm() must be awaited first!");
12703 const nativeResponseValue = wasm.TS_COption_boolZ_some(o);
12704 return nativeResponseValue;
12706 // struct LDKCOption_boolZ COption_boolZ_none(void);
12708 export function COption_boolZ_none(): bigint {
12709 if(!isWasmInitialized) {
12710 throw new Error("initializeWasm() must be awaited first!");
12712 const nativeResponseValue = wasm.TS_COption_boolZ_none();
12713 return nativeResponseValue;
12715 // void COption_boolZ_free(struct LDKCOption_boolZ _res);
12717 export function COption_boolZ_free(_res: bigint): void {
12718 if(!isWasmInitialized) {
12719 throw new Error("initializeWasm() must be awaited first!");
12721 const nativeResponseValue = wasm.TS_COption_boolZ_free(_res);
12722 // debug statements here
12724 // uint64_t COption_boolZ_clone_ptr(LDKCOption_boolZ *NONNULL_PTR arg);
12726 export function COption_boolZ_clone_ptr(arg: bigint): bigint {
12727 if(!isWasmInitialized) {
12728 throw new Error("initializeWasm() must be awaited first!");
12730 const nativeResponseValue = wasm.TS_COption_boolZ_clone_ptr(arg);
12731 return nativeResponseValue;
12733 // struct LDKCOption_boolZ COption_boolZ_clone(const struct LDKCOption_boolZ *NONNULL_PTR orig);
12735 export function COption_boolZ_clone(orig: bigint): bigint {
12736 if(!isWasmInitialized) {
12737 throw new Error("initializeWasm() must be awaited first!");
12739 const nativeResponseValue = wasm.TS_COption_boolZ_clone(orig);
12740 return nativeResponseValue;
12742 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
12744 export function CVec_CVec_u8ZZ_free(_res: number): void {
12745 if(!isWasmInitialized) {
12746 throw new Error("initializeWasm() must be awaited first!");
12748 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
12749 // debug statements here
12751 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
12753 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): bigint {
12754 if(!isWasmInitialized) {
12755 throw new Error("initializeWasm() must be awaited first!");
12757 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
12758 return nativeResponseValue;
12760 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
12762 export function CResult_CVec_CVec_u8ZZNoneZ_err(): bigint {
12763 if(!isWasmInitialized) {
12764 throw new Error("initializeWasm() must be awaited first!");
12766 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
12767 return nativeResponseValue;
12769 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
12771 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: bigint): boolean {
12772 if(!isWasmInitialized) {
12773 throw new Error("initializeWasm() must be awaited first!");
12775 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
12776 return nativeResponseValue;
12778 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
12780 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: bigint): void {
12781 if(!isWasmInitialized) {
12782 throw new Error("initializeWasm() must be awaited first!");
12784 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
12785 // debug statements here
12787 // uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
12789 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: bigint): bigint {
12790 if(!isWasmInitialized) {
12791 throw new Error("initializeWasm() must be awaited first!");
12793 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
12794 return nativeResponseValue;
12796 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
12798 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: bigint): bigint {
12799 if(!isWasmInitialized) {
12800 throw new Error("initializeWasm() must be awaited first!");
12802 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
12803 return nativeResponseValue;
12805 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
12807 export function CResult_InMemorySignerDecodeErrorZ_ok(o: bigint): bigint {
12808 if(!isWasmInitialized) {
12809 throw new Error("initializeWasm() must be awaited first!");
12811 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
12812 return nativeResponseValue;
12814 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
12816 export function CResult_InMemorySignerDecodeErrorZ_err(e: bigint): bigint {
12817 if(!isWasmInitialized) {
12818 throw new Error("initializeWasm() must be awaited first!");
12820 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
12821 return nativeResponseValue;
12823 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
12825 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: bigint): boolean {
12826 if(!isWasmInitialized) {
12827 throw new Error("initializeWasm() must be awaited first!");
12829 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
12830 return nativeResponseValue;
12832 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
12834 export function CResult_InMemorySignerDecodeErrorZ_free(_res: bigint): void {
12835 if(!isWasmInitialized) {
12836 throw new Error("initializeWasm() must be awaited first!");
12838 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
12839 // debug statements here
12841 // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
12843 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12844 if(!isWasmInitialized) {
12845 throw new Error("initializeWasm() must be awaited first!");
12847 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
12848 return nativeResponseValue;
12850 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
12852 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: bigint): bigint {
12853 if(!isWasmInitialized) {
12854 throw new Error("initializeWasm() must be awaited first!");
12856 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
12857 return nativeResponseValue;
12859 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
12861 export function CResult_TransactionNoneZ_ok(o: number): bigint {
12862 if(!isWasmInitialized) {
12863 throw new Error("initializeWasm() must be awaited first!");
12865 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
12866 return nativeResponseValue;
12868 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
12870 export function CResult_TransactionNoneZ_err(): bigint {
12871 if(!isWasmInitialized) {
12872 throw new Error("initializeWasm() must be awaited first!");
12874 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
12875 return nativeResponseValue;
12877 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
12879 export function CResult_TransactionNoneZ_is_ok(o: bigint): boolean {
12880 if(!isWasmInitialized) {
12881 throw new Error("initializeWasm() must be awaited first!");
12883 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
12884 return nativeResponseValue;
12886 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
12888 export function CResult_TransactionNoneZ_free(_res: bigint): void {
12889 if(!isWasmInitialized) {
12890 throw new Error("initializeWasm() must be awaited first!");
12892 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
12893 // debug statements here
12895 // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
12897 export function CResult_TransactionNoneZ_clone_ptr(arg: bigint): bigint {
12898 if(!isWasmInitialized) {
12899 throw new Error("initializeWasm() must be awaited first!");
12901 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
12902 return nativeResponseValue;
12904 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
12906 export function CResult_TransactionNoneZ_clone(orig: bigint): bigint {
12907 if(!isWasmInitialized) {
12908 throw new Error("initializeWasm() must be awaited first!");
12910 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
12911 return nativeResponseValue;
12913 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
12915 export function CVec_ChannelDetailsZ_free(_res: number): void {
12916 if(!isWasmInitialized) {
12917 throw new Error("initializeWasm() must be awaited first!");
12919 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
12920 // debug statements here
12922 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
12924 export function CResult_RouteLightningErrorZ_ok(o: bigint): bigint {
12925 if(!isWasmInitialized) {
12926 throw new Error("initializeWasm() must be awaited first!");
12928 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
12929 return nativeResponseValue;
12931 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
12933 export function CResult_RouteLightningErrorZ_err(e: bigint): bigint {
12934 if(!isWasmInitialized) {
12935 throw new Error("initializeWasm() must be awaited first!");
12937 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
12938 return nativeResponseValue;
12940 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
12942 export function CResult_RouteLightningErrorZ_is_ok(o: bigint): boolean {
12943 if(!isWasmInitialized) {
12944 throw new Error("initializeWasm() must be awaited first!");
12946 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
12947 return nativeResponseValue;
12949 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
12951 export function CResult_RouteLightningErrorZ_free(_res: bigint): void {
12952 if(!isWasmInitialized) {
12953 throw new Error("initializeWasm() must be awaited first!");
12955 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
12956 // debug statements here
12958 // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
12960 export function CResult_RouteLightningErrorZ_clone_ptr(arg: bigint): bigint {
12961 if(!isWasmInitialized) {
12962 throw new Error("initializeWasm() must be awaited first!");
12964 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
12965 return nativeResponseValue;
12967 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
12969 export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
12970 if(!isWasmInitialized) {
12971 throw new Error("initializeWasm() must be awaited first!");
12973 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
12974 return nativeResponseValue;
12976 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
12978 export function CResult_InFlightHtlcsDecodeErrorZ_ok(o: bigint): bigint {
12979 if(!isWasmInitialized) {
12980 throw new Error("initializeWasm() must be awaited first!");
12982 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_ok(o);
12983 return nativeResponseValue;
12985 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_err(struct LDKDecodeError e);
12987 export function CResult_InFlightHtlcsDecodeErrorZ_err(e: bigint): bigint {
12988 if(!isWasmInitialized) {
12989 throw new Error("initializeWasm() must be awaited first!");
12991 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_err(e);
12992 return nativeResponseValue;
12994 // bool CResult_InFlightHtlcsDecodeErrorZ_is_ok(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR o);
12996 export function CResult_InFlightHtlcsDecodeErrorZ_is_ok(o: bigint): boolean {
12997 if(!isWasmInitialized) {
12998 throw new Error("initializeWasm() must be awaited first!");
13000 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(o);
13001 return nativeResponseValue;
13003 // void CResult_InFlightHtlcsDecodeErrorZ_free(struct LDKCResult_InFlightHtlcsDecodeErrorZ _res);
13005 export function CResult_InFlightHtlcsDecodeErrorZ_free(_res: bigint): void {
13006 if(!isWasmInitialized) {
13007 throw new Error("initializeWasm() must be awaited first!");
13009 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_free(_res);
13010 // debug statements here
13012 // uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg);
13014 export function CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13015 if(!isWasmInitialized) {
13016 throw new Error("initializeWasm() must be awaited first!");
13018 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg);
13019 return nativeResponseValue;
13021 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_clone(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR orig);
13023 export function CResult_InFlightHtlcsDecodeErrorZ_clone(orig: bigint): bigint {
13024 if(!isWasmInitialized) {
13025 throw new Error("initializeWasm() must be awaited first!");
13027 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone(orig);
13028 return nativeResponseValue;
13030 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
13032 export function CResult_RouteHopDecodeErrorZ_ok(o: bigint): bigint {
13033 if(!isWasmInitialized) {
13034 throw new Error("initializeWasm() must be awaited first!");
13036 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
13037 return nativeResponseValue;
13039 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
13041 export function CResult_RouteHopDecodeErrorZ_err(e: bigint): bigint {
13042 if(!isWasmInitialized) {
13043 throw new Error("initializeWasm() must be awaited first!");
13045 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
13046 return nativeResponseValue;
13048 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
13050 export function CResult_RouteHopDecodeErrorZ_is_ok(o: bigint): boolean {
13051 if(!isWasmInitialized) {
13052 throw new Error("initializeWasm() must be awaited first!");
13054 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
13055 return nativeResponseValue;
13057 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
13059 export function CResult_RouteHopDecodeErrorZ_free(_res: bigint): void {
13060 if(!isWasmInitialized) {
13061 throw new Error("initializeWasm() must be awaited first!");
13063 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
13064 // debug statements here
13066 // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
13068 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13069 if(!isWasmInitialized) {
13070 throw new Error("initializeWasm() must be awaited first!");
13072 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
13073 return nativeResponseValue;
13075 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
13077 export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
13078 if(!isWasmInitialized) {
13079 throw new Error("initializeWasm() must be awaited first!");
13081 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
13082 return nativeResponseValue;
13084 // void CVec_BlindedHopZ_free(struct LDKCVec_BlindedHopZ _res);
13086 export function CVec_BlindedHopZ_free(_res: number): void {
13087 if(!isWasmInitialized) {
13088 throw new Error("initializeWasm() must be awaited first!");
13090 const nativeResponseValue = wasm.TS_CVec_BlindedHopZ_free(_res);
13091 // debug statements here
13093 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_ok(struct LDKBlindedTail o);
13095 export function CResult_BlindedTailDecodeErrorZ_ok(o: bigint): bigint {
13096 if(!isWasmInitialized) {
13097 throw new Error("initializeWasm() must be awaited first!");
13099 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_ok(o);
13100 return nativeResponseValue;
13102 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_err(struct LDKDecodeError e);
13104 export function CResult_BlindedTailDecodeErrorZ_err(e: bigint): bigint {
13105 if(!isWasmInitialized) {
13106 throw new Error("initializeWasm() must be awaited first!");
13108 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_err(e);
13109 return nativeResponseValue;
13111 // bool CResult_BlindedTailDecodeErrorZ_is_ok(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR o);
13113 export function CResult_BlindedTailDecodeErrorZ_is_ok(o: bigint): boolean {
13114 if(!isWasmInitialized) {
13115 throw new Error("initializeWasm() must be awaited first!");
13117 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_is_ok(o);
13118 return nativeResponseValue;
13120 // void CResult_BlindedTailDecodeErrorZ_free(struct LDKCResult_BlindedTailDecodeErrorZ _res);
13122 export function CResult_BlindedTailDecodeErrorZ_free(_res: bigint): void {
13123 if(!isWasmInitialized) {
13124 throw new Error("initializeWasm() must be awaited first!");
13126 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_free(_res);
13127 // debug statements here
13129 // uint64_t CResult_BlindedTailDecodeErrorZ_clone_ptr(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR arg);
13131 export function CResult_BlindedTailDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13132 if(!isWasmInitialized) {
13133 throw new Error("initializeWasm() must be awaited first!");
13135 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone_ptr(arg);
13136 return nativeResponseValue;
13138 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_clone(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR orig);
13140 export function CResult_BlindedTailDecodeErrorZ_clone(orig: bigint): bigint {
13141 if(!isWasmInitialized) {
13142 throw new Error("initializeWasm() must be awaited first!");
13144 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone(orig);
13145 return nativeResponseValue;
13147 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
13149 export function CVec_RouteHopZ_free(_res: number): void {
13150 if(!isWasmInitialized) {
13151 throw new Error("initializeWasm() must be awaited first!");
13153 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
13154 // debug statements here
13156 // void CVec_PathZ_free(struct LDKCVec_PathZ _res);
13158 export function CVec_PathZ_free(_res: number): void {
13159 if(!isWasmInitialized) {
13160 throw new Error("initializeWasm() must be awaited first!");
13162 const nativeResponseValue = wasm.TS_CVec_PathZ_free(_res);
13163 // debug statements here
13165 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
13167 export function CResult_RouteDecodeErrorZ_ok(o: bigint): bigint {
13168 if(!isWasmInitialized) {
13169 throw new Error("initializeWasm() must be awaited first!");
13171 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
13172 return nativeResponseValue;
13174 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
13176 export function CResult_RouteDecodeErrorZ_err(e: bigint): bigint {
13177 if(!isWasmInitialized) {
13178 throw new Error("initializeWasm() must be awaited first!");
13180 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
13181 return nativeResponseValue;
13183 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
13185 export function CResult_RouteDecodeErrorZ_is_ok(o: bigint): boolean {
13186 if(!isWasmInitialized) {
13187 throw new Error("initializeWasm() must be awaited first!");
13189 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
13190 return nativeResponseValue;
13192 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
13194 export function CResult_RouteDecodeErrorZ_free(_res: bigint): void {
13195 if(!isWasmInitialized) {
13196 throw new Error("initializeWasm() must be awaited first!");
13198 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
13199 // debug statements here
13201 // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
13203 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13204 if(!isWasmInitialized) {
13205 throw new Error("initializeWasm() must be awaited first!");
13207 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
13208 return nativeResponseValue;
13210 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
13212 export function CResult_RouteDecodeErrorZ_clone(orig: bigint): bigint {
13213 if(!isWasmInitialized) {
13214 throw new Error("initializeWasm() must be awaited first!");
13216 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
13217 return nativeResponseValue;
13219 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
13221 export function CResult_RouteParametersDecodeErrorZ_ok(o: bigint): bigint {
13222 if(!isWasmInitialized) {
13223 throw new Error("initializeWasm() must be awaited first!");
13225 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
13226 return nativeResponseValue;
13228 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
13230 export function CResult_RouteParametersDecodeErrorZ_err(e: bigint): bigint {
13231 if(!isWasmInitialized) {
13232 throw new Error("initializeWasm() must be awaited first!");
13234 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
13235 return nativeResponseValue;
13237 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
13239 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: bigint): boolean {
13240 if(!isWasmInitialized) {
13241 throw new Error("initializeWasm() must be awaited first!");
13243 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
13244 return nativeResponseValue;
13246 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
13248 export function CResult_RouteParametersDecodeErrorZ_free(_res: bigint): void {
13249 if(!isWasmInitialized) {
13250 throw new Error("initializeWasm() must be awaited first!");
13252 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
13253 // debug statements here
13255 // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
13257 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13258 if(!isWasmInitialized) {
13259 throw new Error("initializeWasm() must be awaited first!");
13261 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
13262 return nativeResponseValue;
13264 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
13266 export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint {
13267 if(!isWasmInitialized) {
13268 throw new Error("initializeWasm() must be awaited first!");
13270 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
13271 return nativeResponseValue;
13273 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
13275 export function CVec_u64Z_free(_res: number): void {
13276 if(!isWasmInitialized) {
13277 throw new Error("initializeWasm() must be awaited first!");
13279 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
13280 // debug statements here
13282 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
13284 export function CResult_PaymentParametersDecodeErrorZ_ok(o: bigint): bigint {
13285 if(!isWasmInitialized) {
13286 throw new Error("initializeWasm() must be awaited first!");
13288 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
13289 return nativeResponseValue;
13291 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
13293 export function CResult_PaymentParametersDecodeErrorZ_err(e: bigint): bigint {
13294 if(!isWasmInitialized) {
13295 throw new Error("initializeWasm() must be awaited first!");
13297 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
13298 return nativeResponseValue;
13300 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
13302 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: bigint): boolean {
13303 if(!isWasmInitialized) {
13304 throw new Error("initializeWasm() must be awaited first!");
13306 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
13307 return nativeResponseValue;
13309 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
13311 export function CResult_PaymentParametersDecodeErrorZ_free(_res: bigint): void {
13312 if(!isWasmInitialized) {
13313 throw new Error("initializeWasm() must be awaited first!");
13315 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
13316 // debug statements here
13318 // uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
13320 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13321 if(!isWasmInitialized) {
13322 throw new Error("initializeWasm() must be awaited first!");
13324 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
13325 return nativeResponseValue;
13327 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
13329 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigint {
13330 if(!isWasmInitialized) {
13331 throw new Error("initializeWasm() must be awaited first!");
13333 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
13334 return nativeResponseValue;
13336 // uint64_t C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR arg);
13338 export function C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg: bigint): bigint {
13339 if(!isWasmInitialized) {
13340 throw new Error("initializeWasm() must be awaited first!");
13342 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg);
13343 return nativeResponseValue;
13345 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_clone(const struct LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR orig);
13347 export function C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig: bigint): bigint {
13348 if(!isWasmInitialized) {
13349 throw new Error("initializeWasm() must be awaited first!");
13351 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig);
13352 return nativeResponseValue;
13354 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_new(struct LDKBlindedPayInfo a, struct LDKBlindedPath b);
13356 export function C2Tuple_BlindedPayInfoBlindedPathZ_new(a: bigint, b: bigint): bigint {
13357 if(!isWasmInitialized) {
13358 throw new Error("initializeWasm() must be awaited first!");
13360 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_new(a, b);
13361 return nativeResponseValue;
13363 // void C2Tuple_BlindedPayInfoBlindedPathZ_free(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ _res);
13365 export function C2Tuple_BlindedPayInfoBlindedPathZ_free(_res: bigint): void {
13366 if(!isWasmInitialized) {
13367 throw new Error("initializeWasm() must be awaited first!");
13369 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_free(_res);
13370 // debug statements here
13372 // void CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ _res);
13374 export function CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res: number): void {
13375 if(!isWasmInitialized) {
13376 throw new Error("initializeWasm() must be awaited first!");
13378 const nativeResponseValue = wasm.TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res);
13379 // debug statements here
13381 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
13383 export function CVec_RouteHintZ_free(_res: number): void {
13384 if(!isWasmInitialized) {
13385 throw new Error("initializeWasm() must be awaited first!");
13387 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
13388 // debug statements here
13390 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
13392 export function CVec_RouteHintHopZ_free(_res: number): void {
13393 if(!isWasmInitialized) {
13394 throw new Error("initializeWasm() must be awaited first!");
13396 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
13397 // debug statements here
13399 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
13401 export function CResult_RouteHintDecodeErrorZ_ok(o: bigint): bigint {
13402 if(!isWasmInitialized) {
13403 throw new Error("initializeWasm() must be awaited first!");
13405 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
13406 return nativeResponseValue;
13408 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
13410 export function CResult_RouteHintDecodeErrorZ_err(e: bigint): bigint {
13411 if(!isWasmInitialized) {
13412 throw new Error("initializeWasm() must be awaited first!");
13414 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
13415 return nativeResponseValue;
13417 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
13419 export function CResult_RouteHintDecodeErrorZ_is_ok(o: bigint): boolean {
13420 if(!isWasmInitialized) {
13421 throw new Error("initializeWasm() must be awaited first!");
13423 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
13424 return nativeResponseValue;
13426 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
13428 export function CResult_RouteHintDecodeErrorZ_free(_res: bigint): void {
13429 if(!isWasmInitialized) {
13430 throw new Error("initializeWasm() must be awaited first!");
13432 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
13433 // debug statements here
13435 // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
13437 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13438 if(!isWasmInitialized) {
13439 throw new Error("initializeWasm() must be awaited first!");
13441 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
13442 return nativeResponseValue;
13444 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
13446 export function CResult_RouteHintDecodeErrorZ_clone(orig: bigint): bigint {
13447 if(!isWasmInitialized) {
13448 throw new Error("initializeWasm() must be awaited first!");
13450 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
13451 return nativeResponseValue;
13453 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
13455 export function CResult_RouteHintHopDecodeErrorZ_ok(o: bigint): bigint {
13456 if(!isWasmInitialized) {
13457 throw new Error("initializeWasm() must be awaited first!");
13459 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
13460 return nativeResponseValue;
13462 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
13464 export function CResult_RouteHintHopDecodeErrorZ_err(e: bigint): bigint {
13465 if(!isWasmInitialized) {
13466 throw new Error("initializeWasm() must be awaited first!");
13468 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
13469 return nativeResponseValue;
13471 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
13473 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: bigint): boolean {
13474 if(!isWasmInitialized) {
13475 throw new Error("initializeWasm() must be awaited first!");
13477 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
13478 return nativeResponseValue;
13480 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
13482 export function CResult_RouteHintHopDecodeErrorZ_free(_res: bigint): void {
13483 if(!isWasmInitialized) {
13484 throw new Error("initializeWasm() must be awaited first!");
13486 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
13487 // debug statements here
13489 // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
13491 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13492 if(!isWasmInitialized) {
13493 throw new Error("initializeWasm() must be awaited first!");
13495 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
13496 return nativeResponseValue;
13498 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
13500 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
13501 if(!isWasmInitialized) {
13502 throw new Error("initializeWasm() must be awaited first!");
13504 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
13505 return nativeResponseValue;
13507 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
13509 export function CVec_PublicKeyZ_free(_res: number): void {
13510 if(!isWasmInitialized) {
13511 throw new Error("initializeWasm() must be awaited first!");
13513 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
13514 // debug statements here
13516 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
13518 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
13519 if(!isWasmInitialized) {
13520 throw new Error("initializeWasm() must be awaited first!");
13522 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
13523 return nativeResponseValue;
13525 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
13527 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
13528 if(!isWasmInitialized) {
13529 throw new Error("initializeWasm() must be awaited first!");
13531 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
13532 return nativeResponseValue;
13534 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
13536 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
13537 if(!isWasmInitialized) {
13538 throw new Error("initializeWasm() must be awaited first!");
13540 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
13541 return nativeResponseValue;
13543 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
13545 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
13546 if(!isWasmInitialized) {
13547 throw new Error("initializeWasm() must be awaited first!");
13549 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
13550 // debug statements here
13552 // uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
13554 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13555 if(!isWasmInitialized) {
13556 throw new Error("initializeWasm() must be awaited first!");
13558 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
13559 return nativeResponseValue;
13561 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
13563 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
13564 if(!isWasmInitialized) {
13565 throw new Error("initializeWasm() must be awaited first!");
13567 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
13568 return nativeResponseValue;
13570 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
13572 export function CVec_NodeIdZ_free(_res: number): void {
13573 if(!isWasmInitialized) {
13574 throw new Error("initializeWasm() must be awaited first!");
13576 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
13577 // debug statements here
13579 // uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
13581 export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
13582 if(!isWasmInitialized) {
13583 throw new Error("initializeWasm() must be awaited first!");
13585 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
13586 return nativeResponseValue;
13588 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
13590 export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
13591 if(!isWasmInitialized) {
13592 throw new Error("initializeWasm() must be awaited first!");
13594 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
13595 return nativeResponseValue;
13597 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
13599 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
13600 if(!isWasmInitialized) {
13601 throw new Error("initializeWasm() must be awaited first!");
13603 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
13604 return nativeResponseValue;
13606 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
13608 export function C2Tuple_u64u64Z_free(_res: bigint): void {
13609 if(!isWasmInitialized) {
13610 throw new Error("initializeWasm() must be awaited first!");
13612 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
13613 // debug statements here
13615 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
13617 export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
13618 if(!isWasmInitialized) {
13619 throw new Error("initializeWasm() must be awaited first!");
13621 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
13622 return nativeResponseValue;
13624 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
13626 export function COption_C2Tuple_u64u64ZZ_none(): bigint {
13627 if(!isWasmInitialized) {
13628 throw new Error("initializeWasm() must be awaited first!");
13630 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
13631 return nativeResponseValue;
13633 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
13635 export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
13636 if(!isWasmInitialized) {
13637 throw new Error("initializeWasm() must be awaited first!");
13639 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
13640 // debug statements here
13642 // uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
13644 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
13645 if(!isWasmInitialized) {
13646 throw new Error("initializeWasm() must be awaited first!");
13648 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
13649 return nativeResponseValue;
13651 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
13653 export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
13654 if(!isWasmInitialized) {
13655 throw new Error("initializeWasm() must be awaited first!");
13657 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
13658 return nativeResponseValue;
13660 // struct LDKC2Tuple_Z C2Tuple_Z_new(struct LDKThirtyTwoU16s a, struct LDKThirtyTwoU16s b);
13662 export function C2Tuple_Z_new(a: number, b: number): bigint {
13663 if(!isWasmInitialized) {
13664 throw new Error("initializeWasm() must be awaited first!");
13666 const nativeResponseValue = wasm.TS_C2Tuple_Z_new(a, b);
13667 return nativeResponseValue;
13669 // void C2Tuple_Z_free(struct LDKC2Tuple_Z _res);
13671 export function C2Tuple_Z_free(_res: bigint): void {
13672 if(!isWasmInitialized) {
13673 throw new Error("initializeWasm() must be awaited first!");
13675 const nativeResponseValue = wasm.TS_C2Tuple_Z_free(_res);
13676 // debug statements here
13678 // struct LDKC2Tuple__u1632_u1632Z C2Tuple__u1632_u1632Z_new(struct LDKThirtyTwoU16s a, struct LDKThirtyTwoU16s b);
13680 export function C2Tuple__u1632_u1632Z_new(a: number, b: number): bigint {
13681 if(!isWasmInitialized) {
13682 throw new Error("initializeWasm() must be awaited first!");
13684 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_new(a, b);
13685 return nativeResponseValue;
13687 // void C2Tuple__u1632_u1632Z_free(struct LDKC2Tuple__u1632_u1632Z _res);
13689 export function C2Tuple__u1632_u1632Z_free(_res: bigint): void {
13690 if(!isWasmInitialized) {
13691 throw new Error("initializeWasm() must be awaited first!");
13693 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_free(_res);
13694 // debug statements here
13696 // struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(struct LDKC2Tuple__u1632_u1632Z o);
13698 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(o: bigint): bigint {
13699 if(!isWasmInitialized) {
13700 throw new Error("initializeWasm() must be awaited first!");
13702 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(o);
13703 return nativeResponseValue;
13705 // struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none(void);
13707 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none(): bigint {
13708 if(!isWasmInitialized) {
13709 throw new Error("initializeWasm() must be awaited first!");
13711 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none();
13712 return nativeResponseValue;
13714 // void COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ _res);
13716 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(_res: bigint): void {
13717 if(!isWasmInitialized) {
13718 throw new Error("initializeWasm() must be awaited first!");
13720 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(_res);
13721 // debug statements here
13723 // struct LDKCOption_f64Z COption_f64Z_some(double o);
13725 export function COption_f64Z_some(o: number): bigint {
13726 if(!isWasmInitialized) {
13727 throw new Error("initializeWasm() must be awaited first!");
13729 const nativeResponseValue = wasm.TS_COption_f64Z_some(o);
13730 return nativeResponseValue;
13732 // struct LDKCOption_f64Z COption_f64Z_none(void);
13734 export function COption_f64Z_none(): bigint {
13735 if(!isWasmInitialized) {
13736 throw new Error("initializeWasm() must be awaited first!");
13738 const nativeResponseValue = wasm.TS_COption_f64Z_none();
13739 return nativeResponseValue;
13741 // void COption_f64Z_free(struct LDKCOption_f64Z _res);
13743 export function COption_f64Z_free(_res: bigint): void {
13744 if(!isWasmInitialized) {
13745 throw new Error("initializeWasm() must be awaited first!");
13747 const nativeResponseValue = wasm.TS_COption_f64Z_free(_res);
13748 // debug statements here
13750 // uint64_t COption_f64Z_clone_ptr(LDKCOption_f64Z *NONNULL_PTR arg);
13752 export function COption_f64Z_clone_ptr(arg: bigint): bigint {
13753 if(!isWasmInitialized) {
13754 throw new Error("initializeWasm() must be awaited first!");
13756 const nativeResponseValue = wasm.TS_COption_f64Z_clone_ptr(arg);
13757 return nativeResponseValue;
13759 // struct LDKCOption_f64Z COption_f64Z_clone(const struct LDKCOption_f64Z *NONNULL_PTR orig);
13761 export function COption_f64Z_clone(orig: bigint): bigint {
13762 if(!isWasmInitialized) {
13763 throw new Error("initializeWasm() must be awaited first!");
13765 const nativeResponseValue = wasm.TS_COption_f64Z_clone(orig);
13766 return nativeResponseValue;
13768 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
13770 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
13771 if(!isWasmInitialized) {
13772 throw new Error("initializeWasm() must be awaited first!");
13774 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
13775 return nativeResponseValue;
13777 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
13779 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
13780 if(!isWasmInitialized) {
13781 throw new Error("initializeWasm() must be awaited first!");
13783 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
13784 return nativeResponseValue;
13786 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
13788 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
13789 if(!isWasmInitialized) {
13790 throw new Error("initializeWasm() must be awaited first!");
13792 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
13793 return nativeResponseValue;
13795 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
13797 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
13798 if(!isWasmInitialized) {
13799 throw new Error("initializeWasm() must be awaited first!");
13801 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
13802 // debug statements here
13804 // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
13806 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
13807 if(!isWasmInitialized) {
13808 throw new Error("initializeWasm() must be awaited first!");
13810 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
13811 return nativeResponseValue;
13813 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
13815 export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
13816 if(!isWasmInitialized) {
13817 throw new Error("initializeWasm() must be awaited first!");
13819 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
13820 return nativeResponseValue;
13822 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
13824 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
13825 if(!isWasmInitialized) {
13826 throw new Error("initializeWasm() must be awaited first!");
13828 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
13829 return nativeResponseValue;
13831 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
13833 export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
13834 if(!isWasmInitialized) {
13835 throw new Error("initializeWasm() must be awaited first!");
13837 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
13838 // debug statements here
13840 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
13842 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
13843 if(!isWasmInitialized) {
13844 throw new Error("initializeWasm() must be awaited first!");
13846 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
13847 // debug statements here
13849 // uint64_t C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR arg);
13851 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(arg: bigint): bigint {
13852 if(!isWasmInitialized) {
13853 throw new Error("initializeWasm() must be awaited first!");
13855 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(arg);
13856 return nativeResponseValue;
13858 // struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR orig);
13860 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(orig: bigint): bigint {
13861 if(!isWasmInitialized) {
13862 throw new Error("initializeWasm() must be awaited first!");
13864 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(orig);
13865 return nativeResponseValue;
13867 // struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new(struct LDKThirtyTwoBytes a, struct LDKCOption_ThirtyTwoBytesZ b);
13869 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new(a: number, b: bigint): bigint {
13870 if(!isWasmInitialized) {
13871 throw new Error("initializeWasm() must be awaited first!");
13873 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new(a, b);
13874 return nativeResponseValue;
13876 // void C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(struct LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ _res);
13878 export function C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(_res: bigint): void {
13879 if(!isWasmInitialized) {
13880 throw new Error("initializeWasm() must be awaited first!");
13882 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(_res);
13883 // debug statements here
13885 // void CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ _res);
13887 export function CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(_res: number): void {
13888 if(!isWasmInitialized) {
13889 throw new Error("initializeWasm() must be awaited first!");
13891 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(_res);
13892 // debug statements here
13894 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_ok(enum LDKChannelMonitorUpdateStatus o);
13896 export function CResult_ChannelMonitorUpdateStatusNoneZ_ok(o: ChannelMonitorUpdateStatus): bigint {
13897 if(!isWasmInitialized) {
13898 throw new Error("initializeWasm() must be awaited first!");
13900 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_ok(o);
13901 return nativeResponseValue;
13903 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_err(void);
13905 export function CResult_ChannelMonitorUpdateStatusNoneZ_err(): bigint {
13906 if(!isWasmInitialized) {
13907 throw new Error("initializeWasm() must be awaited first!");
13909 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_err();
13910 return nativeResponseValue;
13912 // bool CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR o);
13914 export function CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(o: bigint): boolean {
13915 if(!isWasmInitialized) {
13916 throw new Error("initializeWasm() must be awaited first!");
13918 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(o);
13919 return nativeResponseValue;
13921 // void CResult_ChannelMonitorUpdateStatusNoneZ_free(struct LDKCResult_ChannelMonitorUpdateStatusNoneZ _res);
13923 export function CResult_ChannelMonitorUpdateStatusNoneZ_free(_res: bigint): void {
13924 if(!isWasmInitialized) {
13925 throw new Error("initializeWasm() must be awaited first!");
13927 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_free(_res);
13928 // debug statements here
13930 // uint64_t CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR arg);
13932 export function CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(arg: bigint): bigint {
13933 if(!isWasmInitialized) {
13934 throw new Error("initializeWasm() must be awaited first!");
13936 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(arg);
13937 return nativeResponseValue;
13939 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_clone(const struct LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR orig);
13941 export function CResult_ChannelMonitorUpdateStatusNoneZ_clone(orig: bigint): bigint {
13942 if(!isWasmInitialized) {
13943 throw new Error("initializeWasm() must be awaited first!");
13945 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone(orig);
13946 return nativeResponseValue;
13948 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
13950 export function CVec_MonitorEventZ_free(_res: number): void {
13951 if(!isWasmInitialized) {
13952 throw new Error("initializeWasm() must be awaited first!");
13954 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
13955 // debug statements here
13957 // uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
13959 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
13960 if(!isWasmInitialized) {
13961 throw new Error("initializeWasm() must be awaited first!");
13963 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
13964 return nativeResponseValue;
13966 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
13968 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
13969 if(!isWasmInitialized) {
13970 throw new Error("initializeWasm() must be awaited first!");
13972 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
13973 return nativeResponseValue;
13975 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
13977 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
13978 if(!isWasmInitialized) {
13979 throw new Error("initializeWasm() must be awaited first!");
13981 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
13982 return nativeResponseValue;
13984 // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
13986 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
13987 if(!isWasmInitialized) {
13988 throw new Error("initializeWasm() must be awaited first!");
13990 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
13991 // debug statements here
13993 // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
13995 export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
13996 if(!isWasmInitialized) {
13997 throw new Error("initializeWasm() must be awaited first!");
13999 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
14000 // debug statements here
14002 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
14004 export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14005 if(!isWasmInitialized) {
14006 throw new Error("initializeWasm() must be awaited first!");
14008 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
14009 return nativeResponseValue;
14011 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14013 export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
14014 if(!isWasmInitialized) {
14015 throw new Error("initializeWasm() must be awaited first!");
14017 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
14018 return nativeResponseValue;
14020 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
14022 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14023 if(!isWasmInitialized) {
14024 throw new Error("initializeWasm() must be awaited first!");
14026 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
14027 return nativeResponseValue;
14029 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
14031 export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
14032 if(!isWasmInitialized) {
14033 throw new Error("initializeWasm() must be awaited first!");
14035 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
14036 // debug statements here
14038 // uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
14040 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14041 if(!isWasmInitialized) {
14042 throw new Error("initializeWasm() must be awaited first!");
14044 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
14045 return nativeResponseValue;
14047 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
14049 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14050 if(!isWasmInitialized) {
14051 throw new Error("initializeWasm() must be awaited first!");
14053 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
14054 return nativeResponseValue;
14056 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
14058 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14059 if(!isWasmInitialized) {
14060 throw new Error("initializeWasm() must be awaited first!");
14062 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
14063 return nativeResponseValue;
14065 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14067 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
14068 if(!isWasmInitialized) {
14069 throw new Error("initializeWasm() must be awaited first!");
14071 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
14072 return nativeResponseValue;
14074 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
14076 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14077 if(!isWasmInitialized) {
14078 throw new Error("initializeWasm() must be awaited first!");
14080 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
14081 return nativeResponseValue;
14083 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
14085 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
14086 if(!isWasmInitialized) {
14087 throw new Error("initializeWasm() must be awaited first!");
14089 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
14090 // debug statements here
14092 // uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
14094 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14095 if(!isWasmInitialized) {
14096 throw new Error("initializeWasm() must be awaited first!");
14098 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
14099 return nativeResponseValue;
14101 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
14103 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14104 if(!isWasmInitialized) {
14105 throw new Error("initializeWasm() must be awaited first!");
14107 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
14108 return nativeResponseValue;
14110 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
14112 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14113 if(!isWasmInitialized) {
14114 throw new Error("initializeWasm() must be awaited first!");
14116 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
14117 return nativeResponseValue;
14119 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14121 export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
14122 if(!isWasmInitialized) {
14123 throw new Error("initializeWasm() must be awaited first!");
14125 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
14126 return nativeResponseValue;
14128 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
14130 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14131 if(!isWasmInitialized) {
14132 throw new Error("initializeWasm() must be awaited first!");
14134 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
14135 return nativeResponseValue;
14137 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
14139 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
14140 if(!isWasmInitialized) {
14141 throw new Error("initializeWasm() must be awaited first!");
14143 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
14144 // debug statements here
14146 // uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
14148 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14149 if(!isWasmInitialized) {
14150 throw new Error("initializeWasm() must be awaited first!");
14152 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
14153 return nativeResponseValue;
14155 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
14157 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14158 if(!isWasmInitialized) {
14159 throw new Error("initializeWasm() must be awaited first!");
14161 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
14162 return nativeResponseValue;
14164 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt11InvoiceFeatures o);
14166 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14167 if(!isWasmInitialized) {
14168 throw new Error("initializeWasm() must be awaited first!");
14170 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o);
14171 return nativeResponseValue;
14173 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14175 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
14176 if(!isWasmInitialized) {
14177 throw new Error("initializeWasm() must be awaited first!");
14179 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e);
14180 return nativeResponseValue;
14182 // bool CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
14184 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14185 if(!isWasmInitialized) {
14186 throw new Error("initializeWasm() must be awaited first!");
14188 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o);
14189 return nativeResponseValue;
14191 // void CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ _res);
14193 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
14194 if(!isWasmInitialized) {
14195 throw new Error("initializeWasm() must be awaited first!");
14197 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res);
14198 // debug statements here
14200 // uint64_t CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
14202 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14203 if(!isWasmInitialized) {
14204 throw new Error("initializeWasm() must be awaited first!");
14206 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
14207 return nativeResponseValue;
14209 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
14211 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14212 if(!isWasmInitialized) {
14213 throw new Error("initializeWasm() must be awaited first!");
14215 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig);
14216 return nativeResponseValue;
14218 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt12InvoiceFeatures o);
14220 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14221 if(!isWasmInitialized) {
14222 throw new Error("initializeWasm() must be awaited first!");
14224 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o);
14225 return nativeResponseValue;
14227 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14229 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
14230 if(!isWasmInitialized) {
14231 throw new Error("initializeWasm() must be awaited first!");
14233 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e);
14234 return nativeResponseValue;
14236 // bool CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
14238 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14239 if(!isWasmInitialized) {
14240 throw new Error("initializeWasm() must be awaited first!");
14242 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o);
14243 return nativeResponseValue;
14245 // void CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ _res);
14247 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
14248 if(!isWasmInitialized) {
14249 throw new Error("initializeWasm() must be awaited first!");
14251 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res);
14252 // debug statements here
14254 // uint64_t CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
14256 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14257 if(!isWasmInitialized) {
14258 throw new Error("initializeWasm() must be awaited first!");
14260 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
14261 return nativeResponseValue;
14263 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
14265 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14266 if(!isWasmInitialized) {
14267 throw new Error("initializeWasm() must be awaited first!");
14269 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig);
14270 return nativeResponseValue;
14272 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_ok(struct LDKBlindedHopFeatures o);
14274 export function CResult_BlindedHopFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14275 if(!isWasmInitialized) {
14276 throw new Error("initializeWasm() must be awaited first!");
14278 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(o);
14279 return nativeResponseValue;
14281 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14283 export function CResult_BlindedHopFeaturesDecodeErrorZ_err(e: bigint): bigint {
14284 if(!isWasmInitialized) {
14285 throw new Error("initializeWasm() must be awaited first!");
14287 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(e);
14288 return nativeResponseValue;
14290 // bool CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR o);
14292 export function CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14293 if(!isWasmInitialized) {
14294 throw new Error("initializeWasm() must be awaited first!");
14296 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o);
14297 return nativeResponseValue;
14299 // void CResult_BlindedHopFeaturesDecodeErrorZ_free(struct LDKCResult_BlindedHopFeaturesDecodeErrorZ _res);
14301 export function CResult_BlindedHopFeaturesDecodeErrorZ_free(_res: bigint): void {
14302 if(!isWasmInitialized) {
14303 throw new Error("initializeWasm() must be awaited first!");
14305 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(_res);
14306 // debug statements here
14308 // uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg);
14310 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14311 if(!isWasmInitialized) {
14312 throw new Error("initializeWasm() must be awaited first!");
14314 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg);
14315 return nativeResponseValue;
14317 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_clone(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR orig);
14319 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14320 if(!isWasmInitialized) {
14321 throw new Error("initializeWasm() must be awaited first!");
14323 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig);
14324 return nativeResponseValue;
14326 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
14328 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14329 if(!isWasmInitialized) {
14330 throw new Error("initializeWasm() must be awaited first!");
14332 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
14333 return nativeResponseValue;
14335 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14337 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
14338 if(!isWasmInitialized) {
14339 throw new Error("initializeWasm() must be awaited first!");
14341 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
14342 return nativeResponseValue;
14344 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
14346 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14347 if(!isWasmInitialized) {
14348 throw new Error("initializeWasm() must be awaited first!");
14350 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
14351 return nativeResponseValue;
14353 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
14355 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
14356 if(!isWasmInitialized) {
14357 throw new Error("initializeWasm() must be awaited first!");
14359 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
14360 // debug statements here
14362 // uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
14364 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14365 if(!isWasmInitialized) {
14366 throw new Error("initializeWasm() must be awaited first!");
14368 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
14369 return nativeResponseValue;
14371 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
14373 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14374 if(!isWasmInitialized) {
14375 throw new Error("initializeWasm() must be awaited first!");
14377 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
14378 return nativeResponseValue;
14380 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_ok(struct LDKOffer o);
14382 export function CResult_OfferBolt12ParseErrorZ_ok(o: bigint): bigint {
14383 if(!isWasmInitialized) {
14384 throw new Error("initializeWasm() must be awaited first!");
14386 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_ok(o);
14387 return nativeResponseValue;
14389 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
14391 export function CResult_OfferBolt12ParseErrorZ_err(e: bigint): bigint {
14392 if(!isWasmInitialized) {
14393 throw new Error("initializeWasm() must be awaited first!");
14395 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_err(e);
14396 return nativeResponseValue;
14398 // bool CResult_OfferBolt12ParseErrorZ_is_ok(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR o);
14400 export function CResult_OfferBolt12ParseErrorZ_is_ok(o: bigint): boolean {
14401 if(!isWasmInitialized) {
14402 throw new Error("initializeWasm() must be awaited first!");
14404 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_is_ok(o);
14405 return nativeResponseValue;
14407 // void CResult_OfferBolt12ParseErrorZ_free(struct LDKCResult_OfferBolt12ParseErrorZ _res);
14409 export function CResult_OfferBolt12ParseErrorZ_free(_res: bigint): void {
14410 if(!isWasmInitialized) {
14411 throw new Error("initializeWasm() must be awaited first!");
14413 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_free(_res);
14414 // debug statements here
14416 // uint64_t CResult_OfferBolt12ParseErrorZ_clone_ptr(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR arg);
14418 export function CResult_OfferBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
14419 if(!isWasmInitialized) {
14420 throw new Error("initializeWasm() must be awaited first!");
14422 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone_ptr(arg);
14423 return nativeResponseValue;
14425 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_clone(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR orig);
14427 export function CResult_OfferBolt12ParseErrorZ_clone(orig: bigint): bigint {
14428 if(!isWasmInitialized) {
14429 throw new Error("initializeWasm() must be awaited first!");
14431 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone(orig);
14432 return nativeResponseValue;
14434 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_ok(struct LDKPublicKey o);
14436 export function CResult_PublicKeySecp256k1ErrorZ_ok(o: number): bigint {
14437 if(!isWasmInitialized) {
14438 throw new Error("initializeWasm() must be awaited first!");
14440 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_ok(o);
14441 return nativeResponseValue;
14443 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
14445 export function CResult_PublicKeySecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
14446 if(!isWasmInitialized) {
14447 throw new Error("initializeWasm() must be awaited first!");
14449 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_err(e);
14450 return nativeResponseValue;
14452 // bool CResult_PublicKeySecp256k1ErrorZ_is_ok(const struct LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR o);
14454 export function CResult_PublicKeySecp256k1ErrorZ_is_ok(o: bigint): boolean {
14455 if(!isWasmInitialized) {
14456 throw new Error("initializeWasm() must be awaited first!");
14458 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_is_ok(o);
14459 return nativeResponseValue;
14461 // void CResult_PublicKeySecp256k1ErrorZ_free(struct LDKCResult_PublicKeySecp256k1ErrorZ _res);
14463 export function CResult_PublicKeySecp256k1ErrorZ_free(_res: bigint): void {
14464 if(!isWasmInitialized) {
14465 throw new Error("initializeWasm() must be awaited first!");
14467 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_free(_res);
14468 // debug statements here
14470 // uint64_t CResult_PublicKeySecp256k1ErrorZ_clone_ptr(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR arg);
14472 export function CResult_PublicKeySecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
14473 if(!isWasmInitialized) {
14474 throw new Error("initializeWasm() must be awaited first!");
14476 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_clone_ptr(arg);
14477 return nativeResponseValue;
14479 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_clone(const struct LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR orig);
14481 export function CResult_PublicKeySecp256k1ErrorZ_clone(orig: bigint): bigint {
14482 if(!isWasmInitialized) {
14483 throw new Error("initializeWasm() must be awaited first!");
14485 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_clone(orig);
14486 return nativeResponseValue;
14488 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
14490 export function CResult_NodeIdDecodeErrorZ_ok(o: bigint): bigint {
14491 if(!isWasmInitialized) {
14492 throw new Error("initializeWasm() must be awaited first!");
14494 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
14495 return nativeResponseValue;
14497 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
14499 export function CResult_NodeIdDecodeErrorZ_err(e: bigint): bigint {
14500 if(!isWasmInitialized) {
14501 throw new Error("initializeWasm() must be awaited first!");
14503 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
14504 return nativeResponseValue;
14506 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
14508 export function CResult_NodeIdDecodeErrorZ_is_ok(o: bigint): boolean {
14509 if(!isWasmInitialized) {
14510 throw new Error("initializeWasm() must be awaited first!");
14512 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
14513 return nativeResponseValue;
14515 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
14517 export function CResult_NodeIdDecodeErrorZ_free(_res: bigint): void {
14518 if(!isWasmInitialized) {
14519 throw new Error("initializeWasm() must be awaited first!");
14521 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
14522 // debug statements here
14524 // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
14526 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14527 if(!isWasmInitialized) {
14528 throw new Error("initializeWasm() must be awaited first!");
14530 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
14531 return nativeResponseValue;
14533 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
14535 export function CResult_NodeIdDecodeErrorZ_clone(orig: bigint): bigint {
14536 if(!isWasmInitialized) {
14537 throw new Error("initializeWasm() must be awaited first!");
14539 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
14540 return nativeResponseValue;
14542 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
14544 export function COption_NetworkUpdateZ_some(o: bigint): bigint {
14545 if(!isWasmInitialized) {
14546 throw new Error("initializeWasm() must be awaited first!");
14548 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
14549 return nativeResponseValue;
14551 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
14553 export function COption_NetworkUpdateZ_none(): bigint {
14554 if(!isWasmInitialized) {
14555 throw new Error("initializeWasm() must be awaited first!");
14557 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
14558 return nativeResponseValue;
14560 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
14562 export function COption_NetworkUpdateZ_free(_res: bigint): void {
14563 if(!isWasmInitialized) {
14564 throw new Error("initializeWasm() must be awaited first!");
14566 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
14567 // debug statements here
14569 // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
14571 export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
14572 if(!isWasmInitialized) {
14573 throw new Error("initializeWasm() must be awaited first!");
14575 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
14576 return nativeResponseValue;
14578 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
14580 export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
14581 if(!isWasmInitialized) {
14582 throw new Error("initializeWasm() must be awaited first!");
14584 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
14585 return nativeResponseValue;
14587 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
14589 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: bigint): bigint {
14590 if(!isWasmInitialized) {
14591 throw new Error("initializeWasm() must be awaited first!");
14593 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
14594 return nativeResponseValue;
14596 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
14598 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: bigint): bigint {
14599 if(!isWasmInitialized) {
14600 throw new Error("initializeWasm() must be awaited first!");
14602 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
14603 return nativeResponseValue;
14605 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
14607 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: bigint): boolean {
14608 if(!isWasmInitialized) {
14609 throw new Error("initializeWasm() must be awaited first!");
14611 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
14612 return nativeResponseValue;
14614 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
14616 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: bigint): void {
14617 if(!isWasmInitialized) {
14618 throw new Error("initializeWasm() must be awaited first!");
14620 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
14621 // debug statements here
14623 // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
14625 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14626 if(!isWasmInitialized) {
14627 throw new Error("initializeWasm() must be awaited first!");
14629 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
14630 return nativeResponseValue;
14632 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
14634 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: bigint): bigint {
14635 if(!isWasmInitialized) {
14636 throw new Error("initializeWasm() must be awaited first!");
14638 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
14639 return nativeResponseValue;
14641 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_some(struct LDKUtxoLookup o);
14643 export function COption_UtxoLookupZ_some(o: bigint): bigint {
14644 if(!isWasmInitialized) {
14645 throw new Error("initializeWasm() must be awaited first!");
14647 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_some(o);
14648 return nativeResponseValue;
14650 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_none(void);
14652 export function COption_UtxoLookupZ_none(): bigint {
14653 if(!isWasmInitialized) {
14654 throw new Error("initializeWasm() must be awaited first!");
14656 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_none();
14657 return nativeResponseValue;
14659 // void COption_UtxoLookupZ_free(struct LDKCOption_UtxoLookupZ _res);
14661 export function COption_UtxoLookupZ_free(_res: bigint): void {
14662 if(!isWasmInitialized) {
14663 throw new Error("initializeWasm() must be awaited first!");
14665 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_free(_res);
14666 // debug statements here
14668 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
14670 export function CResult_NoneLightningErrorZ_ok(): bigint {
14671 if(!isWasmInitialized) {
14672 throw new Error("initializeWasm() must be awaited first!");
14674 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
14675 return nativeResponseValue;
14677 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
14679 export function CResult_NoneLightningErrorZ_err(e: bigint): bigint {
14680 if(!isWasmInitialized) {
14681 throw new Error("initializeWasm() must be awaited first!");
14683 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
14684 return nativeResponseValue;
14686 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
14688 export function CResult_NoneLightningErrorZ_is_ok(o: bigint): boolean {
14689 if(!isWasmInitialized) {
14690 throw new Error("initializeWasm() must be awaited first!");
14692 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
14693 return nativeResponseValue;
14695 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
14697 export function CResult_NoneLightningErrorZ_free(_res: bigint): void {
14698 if(!isWasmInitialized) {
14699 throw new Error("initializeWasm() must be awaited first!");
14701 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
14702 // debug statements here
14704 // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
14706 export function CResult_NoneLightningErrorZ_clone_ptr(arg: bigint): bigint {
14707 if(!isWasmInitialized) {
14708 throw new Error("initializeWasm() must be awaited first!");
14710 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
14711 return nativeResponseValue;
14713 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
14715 export function CResult_NoneLightningErrorZ_clone(orig: bigint): bigint {
14716 if(!isWasmInitialized) {
14717 throw new Error("initializeWasm() must be awaited first!");
14719 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
14720 return nativeResponseValue;
14722 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
14724 export function CResult_boolLightningErrorZ_ok(o: boolean): bigint {
14725 if(!isWasmInitialized) {
14726 throw new Error("initializeWasm() must be awaited first!");
14728 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
14729 return nativeResponseValue;
14731 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
14733 export function CResult_boolLightningErrorZ_err(e: bigint): bigint {
14734 if(!isWasmInitialized) {
14735 throw new Error("initializeWasm() must be awaited first!");
14737 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
14738 return nativeResponseValue;
14740 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
14742 export function CResult_boolLightningErrorZ_is_ok(o: bigint): boolean {
14743 if(!isWasmInitialized) {
14744 throw new Error("initializeWasm() must be awaited first!");
14746 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
14747 return nativeResponseValue;
14749 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
14751 export function CResult_boolLightningErrorZ_free(_res: bigint): void {
14752 if(!isWasmInitialized) {
14753 throw new Error("initializeWasm() must be awaited first!");
14755 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
14756 // debug statements here
14758 // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
14760 export function CResult_boolLightningErrorZ_clone_ptr(arg: bigint): bigint {
14761 if(!isWasmInitialized) {
14762 throw new Error("initializeWasm() must be awaited first!");
14764 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
14765 return nativeResponseValue;
14767 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
14769 export function CResult_boolLightningErrorZ_clone(orig: bigint): bigint {
14770 if(!isWasmInitialized) {
14771 throw new Error("initializeWasm() must be awaited first!");
14773 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
14774 return nativeResponseValue;
14776 // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
14778 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: bigint): bigint {
14779 if(!isWasmInitialized) {
14780 throw new Error("initializeWasm() must be awaited first!");
14782 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
14783 return nativeResponseValue;
14785 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
14787 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: bigint): bigint {
14788 if(!isWasmInitialized) {
14789 throw new Error("initializeWasm() must be awaited first!");
14791 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
14792 return nativeResponseValue;
14794 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
14796 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: bigint, b: bigint, c: bigint): bigint {
14797 if(!isWasmInitialized) {
14798 throw new Error("initializeWasm() must be awaited first!");
14800 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
14801 return nativeResponseValue;
14803 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
14805 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: bigint): void {
14806 if(!isWasmInitialized) {
14807 throw new Error("initializeWasm() must be awaited first!");
14809 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
14810 // debug statements here
14812 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o);
14814 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o: bigint): bigint {
14815 if(!isWasmInitialized) {
14816 throw new Error("initializeWasm() must be awaited first!");
14818 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o);
14819 return nativeResponseValue;
14821 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(void);
14823 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(): bigint {
14824 if(!isWasmInitialized) {
14825 throw new Error("initializeWasm() must be awaited first!");
14827 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
14828 return nativeResponseValue;
14830 // void COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
14832 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: bigint): void {
14833 if(!isWasmInitialized) {
14834 throw new Error("initializeWasm() must be awaited first!");
14836 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
14837 // debug statements here
14839 // uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg);
14841 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg: bigint): bigint {
14842 if(!isWasmInitialized) {
14843 throw new Error("initializeWasm() must be awaited first!");
14845 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg);
14846 return nativeResponseValue;
14848 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR orig);
14850 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig: bigint): bigint {
14851 if(!isWasmInitialized) {
14852 throw new Error("initializeWasm() must be awaited first!");
14854 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig);
14855 return nativeResponseValue;
14857 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
14859 export function CVec_MessageSendEventZ_free(_res: number): void {
14860 if(!isWasmInitialized) {
14861 throw new Error("initializeWasm() must be awaited first!");
14863 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
14864 // debug statements here
14866 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
14868 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: bigint): bigint {
14869 if(!isWasmInitialized) {
14870 throw new Error("initializeWasm() must be awaited first!");
14872 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
14873 return nativeResponseValue;
14875 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
14877 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: bigint): bigint {
14878 if(!isWasmInitialized) {
14879 throw new Error("initializeWasm() must be awaited first!");
14881 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
14882 return nativeResponseValue;
14884 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
14886 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: bigint): boolean {
14887 if(!isWasmInitialized) {
14888 throw new Error("initializeWasm() must be awaited first!");
14890 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
14891 return nativeResponseValue;
14893 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
14895 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: bigint): void {
14896 if(!isWasmInitialized) {
14897 throw new Error("initializeWasm() must be awaited first!");
14899 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
14900 // debug statements here
14902 // uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
14904 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14905 if(!isWasmInitialized) {
14906 throw new Error("initializeWasm() must be awaited first!");
14908 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
14909 return nativeResponseValue;
14911 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
14913 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: bigint): bigint {
14914 if(!isWasmInitialized) {
14915 throw new Error("initializeWasm() must be awaited first!");
14917 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
14918 return nativeResponseValue;
14920 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
14922 export function CResult_ChannelInfoDecodeErrorZ_ok(o: bigint): bigint {
14923 if(!isWasmInitialized) {
14924 throw new Error("initializeWasm() must be awaited first!");
14926 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
14927 return nativeResponseValue;
14929 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
14931 export function CResult_ChannelInfoDecodeErrorZ_err(e: bigint): bigint {
14932 if(!isWasmInitialized) {
14933 throw new Error("initializeWasm() must be awaited first!");
14935 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
14936 return nativeResponseValue;
14938 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
14940 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: bigint): boolean {
14941 if(!isWasmInitialized) {
14942 throw new Error("initializeWasm() must be awaited first!");
14944 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
14945 return nativeResponseValue;
14947 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
14949 export function CResult_ChannelInfoDecodeErrorZ_free(_res: bigint): void {
14950 if(!isWasmInitialized) {
14951 throw new Error("initializeWasm() must be awaited first!");
14953 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
14954 // debug statements here
14956 // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
14958 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14959 if(!isWasmInitialized) {
14960 throw new Error("initializeWasm() must be awaited first!");
14962 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
14963 return nativeResponseValue;
14965 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
14967 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: bigint): bigint {
14968 if(!isWasmInitialized) {
14969 throw new Error("initializeWasm() must be awaited first!");
14971 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
14972 return nativeResponseValue;
14974 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
14976 export function CResult_RoutingFeesDecodeErrorZ_ok(o: bigint): bigint {
14977 if(!isWasmInitialized) {
14978 throw new Error("initializeWasm() must be awaited first!");
14980 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
14981 return nativeResponseValue;
14983 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
14985 export function CResult_RoutingFeesDecodeErrorZ_err(e: bigint): bigint {
14986 if(!isWasmInitialized) {
14987 throw new Error("initializeWasm() must be awaited first!");
14989 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
14990 return nativeResponseValue;
14992 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
14994 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: bigint): boolean {
14995 if(!isWasmInitialized) {
14996 throw new Error("initializeWasm() must be awaited first!");
14998 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
14999 return nativeResponseValue;
15001 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
15003 export function CResult_RoutingFeesDecodeErrorZ_free(_res: bigint): void {
15004 if(!isWasmInitialized) {
15005 throw new Error("initializeWasm() must be awaited first!");
15007 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
15008 // debug statements here
15010 // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
15012 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15013 if(!isWasmInitialized) {
15014 throw new Error("initializeWasm() must be awaited first!");
15016 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
15017 return nativeResponseValue;
15019 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
15021 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: bigint): bigint {
15022 if(!isWasmInitialized) {
15023 throw new Error("initializeWasm() must be awaited first!");
15025 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
15026 return nativeResponseValue;
15028 // void CVec_SocketAddressZ_free(struct LDKCVec_SocketAddressZ _res);
15030 export function CVec_SocketAddressZ_free(_res: number): void {
15031 if(!isWasmInitialized) {
15032 throw new Error("initializeWasm() must be awaited first!");
15034 const nativeResponseValue = wasm.TS_CVec_SocketAddressZ_free(_res);
15035 // debug statements here
15037 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
15039 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: bigint): bigint {
15040 if(!isWasmInitialized) {
15041 throw new Error("initializeWasm() must be awaited first!");
15043 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
15044 return nativeResponseValue;
15046 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
15048 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: bigint): bigint {
15049 if(!isWasmInitialized) {
15050 throw new Error("initializeWasm() must be awaited first!");
15052 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
15053 return nativeResponseValue;
15055 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
15057 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: bigint): boolean {
15058 if(!isWasmInitialized) {
15059 throw new Error("initializeWasm() must be awaited first!");
15061 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
15062 return nativeResponseValue;
15064 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
15066 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: bigint): void {
15067 if(!isWasmInitialized) {
15068 throw new Error("initializeWasm() must be awaited first!");
15070 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
15071 // debug statements here
15073 // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
15075 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15076 if(!isWasmInitialized) {
15077 throw new Error("initializeWasm() must be awaited first!");
15079 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
15080 return nativeResponseValue;
15082 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
15084 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: bigint): bigint {
15085 if(!isWasmInitialized) {
15086 throw new Error("initializeWasm() must be awaited first!");
15088 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
15089 return nativeResponseValue;
15091 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
15093 export function CResult_NodeAliasDecodeErrorZ_ok(o: bigint): bigint {
15094 if(!isWasmInitialized) {
15095 throw new Error("initializeWasm() must be awaited first!");
15097 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
15098 return nativeResponseValue;
15100 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
15102 export function CResult_NodeAliasDecodeErrorZ_err(e: bigint): bigint {
15103 if(!isWasmInitialized) {
15104 throw new Error("initializeWasm() must be awaited first!");
15106 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
15107 return nativeResponseValue;
15109 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
15111 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: bigint): boolean {
15112 if(!isWasmInitialized) {
15113 throw new Error("initializeWasm() must be awaited first!");
15115 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
15116 return nativeResponseValue;
15118 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
15120 export function CResult_NodeAliasDecodeErrorZ_free(_res: bigint): void {
15121 if(!isWasmInitialized) {
15122 throw new Error("initializeWasm() must be awaited first!");
15124 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
15125 // debug statements here
15127 // uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
15129 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15130 if(!isWasmInitialized) {
15131 throw new Error("initializeWasm() must be awaited first!");
15133 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
15134 return nativeResponseValue;
15136 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
15138 export function CResult_NodeAliasDecodeErrorZ_clone(orig: bigint): bigint {
15139 if(!isWasmInitialized) {
15140 throw new Error("initializeWasm() must be awaited first!");
15142 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
15143 return nativeResponseValue;
15145 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
15147 export function CResult_NodeInfoDecodeErrorZ_ok(o: bigint): bigint {
15148 if(!isWasmInitialized) {
15149 throw new Error("initializeWasm() must be awaited first!");
15151 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
15152 return nativeResponseValue;
15154 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
15156 export function CResult_NodeInfoDecodeErrorZ_err(e: bigint): bigint {
15157 if(!isWasmInitialized) {
15158 throw new Error("initializeWasm() must be awaited first!");
15160 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
15161 return nativeResponseValue;
15163 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
15165 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: bigint): boolean {
15166 if(!isWasmInitialized) {
15167 throw new Error("initializeWasm() must be awaited first!");
15169 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
15170 return nativeResponseValue;
15172 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
15174 export function CResult_NodeInfoDecodeErrorZ_free(_res: bigint): void {
15175 if(!isWasmInitialized) {
15176 throw new Error("initializeWasm() must be awaited first!");
15178 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
15179 // debug statements here
15181 // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
15183 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15184 if(!isWasmInitialized) {
15185 throw new Error("initializeWasm() must be awaited first!");
15187 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
15188 return nativeResponseValue;
15190 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
15192 export function CResult_NodeInfoDecodeErrorZ_clone(orig: bigint): bigint {
15193 if(!isWasmInitialized) {
15194 throw new Error("initializeWasm() must be awaited first!");
15196 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
15197 return nativeResponseValue;
15199 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
15201 export function CResult_NetworkGraphDecodeErrorZ_ok(o: bigint): bigint {
15202 if(!isWasmInitialized) {
15203 throw new Error("initializeWasm() must be awaited first!");
15205 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
15206 return nativeResponseValue;
15208 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
15210 export function CResult_NetworkGraphDecodeErrorZ_err(e: bigint): bigint {
15211 if(!isWasmInitialized) {
15212 throw new Error("initializeWasm() must be awaited first!");
15214 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
15215 return nativeResponseValue;
15217 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
15219 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: bigint): boolean {
15220 if(!isWasmInitialized) {
15221 throw new Error("initializeWasm() must be awaited first!");
15223 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
15224 return nativeResponseValue;
15226 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
15228 export function CResult_NetworkGraphDecodeErrorZ_free(_res: bigint): void {
15229 if(!isWasmInitialized) {
15230 throw new Error("initializeWasm() must be awaited first!");
15232 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
15233 // debug statements here
15235 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_some(struct LDKCVec_SocketAddressZ o);
15237 export function COption_CVec_SocketAddressZZ_some(o: number): bigint {
15238 if(!isWasmInitialized) {
15239 throw new Error("initializeWasm() must be awaited first!");
15241 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_some(o);
15242 return nativeResponseValue;
15244 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_none(void);
15246 export function COption_CVec_SocketAddressZZ_none(): bigint {
15247 if(!isWasmInitialized) {
15248 throw new Error("initializeWasm() must be awaited first!");
15250 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_none();
15251 return nativeResponseValue;
15253 // void COption_CVec_SocketAddressZZ_free(struct LDKCOption_CVec_SocketAddressZZ _res);
15255 export function COption_CVec_SocketAddressZZ_free(_res: bigint): void {
15256 if(!isWasmInitialized) {
15257 throw new Error("initializeWasm() must be awaited first!");
15259 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_free(_res);
15260 // debug statements here
15262 // uint64_t COption_CVec_SocketAddressZZ_clone_ptr(LDKCOption_CVec_SocketAddressZZ *NONNULL_PTR arg);
15264 export function COption_CVec_SocketAddressZZ_clone_ptr(arg: bigint): bigint {
15265 if(!isWasmInitialized) {
15266 throw new Error("initializeWasm() must be awaited first!");
15268 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_clone_ptr(arg);
15269 return nativeResponseValue;
15271 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_clone(const struct LDKCOption_CVec_SocketAddressZZ *NONNULL_PTR orig);
15273 export function COption_CVec_SocketAddressZZ_clone(orig: bigint): bigint {
15274 if(!isWasmInitialized) {
15275 throw new Error("initializeWasm() must be awaited first!");
15277 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_clone(orig);
15278 return nativeResponseValue;
15280 // void CVec_HTLCOutputInCommitmentZ_free(struct LDKCVec_HTLCOutputInCommitmentZ _res);
15282 export function CVec_HTLCOutputInCommitmentZ_free(_res: number): void {
15283 if(!isWasmInitialized) {
15284 throw new Error("initializeWasm() must be awaited first!");
15286 const nativeResponseValue = wasm.TS_CVec_HTLCOutputInCommitmentZ_free(_res);
15287 // debug statements here
15289 // void CVec_HTLCDescriptorZ_free(struct LDKCVec_HTLCDescriptorZ _res);
15291 export function CVec_HTLCDescriptorZ_free(_res: number): void {
15292 if(!isWasmInitialized) {
15293 throw new Error("initializeWasm() must be awaited first!");
15295 const nativeResponseValue = wasm.TS_CVec_HTLCDescriptorZ_free(_res);
15296 // debug statements here
15298 // void CVec_UtxoZ_free(struct LDKCVec_UtxoZ _res);
15300 export function CVec_UtxoZ_free(_res: number): void {
15301 if(!isWasmInitialized) {
15302 throw new Error("initializeWasm() must be awaited first!");
15304 const nativeResponseValue = wasm.TS_CVec_UtxoZ_free(_res);
15305 // debug statements here
15307 // struct LDKCOption_TxOutZ COption_TxOutZ_some(struct LDKTxOut o);
15309 export function COption_TxOutZ_some(o: bigint): bigint {
15310 if(!isWasmInitialized) {
15311 throw new Error("initializeWasm() must be awaited first!");
15313 const nativeResponseValue = wasm.TS_COption_TxOutZ_some(o);
15314 return nativeResponseValue;
15316 // struct LDKCOption_TxOutZ COption_TxOutZ_none(void);
15318 export function COption_TxOutZ_none(): bigint {
15319 if(!isWasmInitialized) {
15320 throw new Error("initializeWasm() must be awaited first!");
15322 const nativeResponseValue = wasm.TS_COption_TxOutZ_none();
15323 return nativeResponseValue;
15325 // void COption_TxOutZ_free(struct LDKCOption_TxOutZ _res);
15327 export function COption_TxOutZ_free(_res: bigint): void {
15328 if(!isWasmInitialized) {
15329 throw new Error("initializeWasm() must be awaited first!");
15331 const nativeResponseValue = wasm.TS_COption_TxOutZ_free(_res);
15332 // debug statements here
15334 // uint64_t COption_TxOutZ_clone_ptr(LDKCOption_TxOutZ *NONNULL_PTR arg);
15336 export function COption_TxOutZ_clone_ptr(arg: bigint): bigint {
15337 if(!isWasmInitialized) {
15338 throw new Error("initializeWasm() must be awaited first!");
15340 const nativeResponseValue = wasm.TS_COption_TxOutZ_clone_ptr(arg);
15341 return nativeResponseValue;
15343 // struct LDKCOption_TxOutZ COption_TxOutZ_clone(const struct LDKCOption_TxOutZ *NONNULL_PTR orig);
15345 export function COption_TxOutZ_clone(orig: bigint): bigint {
15346 if(!isWasmInitialized) {
15347 throw new Error("initializeWasm() must be awaited first!");
15349 const nativeResponseValue = wasm.TS_COption_TxOutZ_clone(orig);
15350 return nativeResponseValue;
15352 // void CVec_InputZ_free(struct LDKCVec_InputZ _res);
15354 export function CVec_InputZ_free(_res: number): void {
15355 if(!isWasmInitialized) {
15356 throw new Error("initializeWasm() must be awaited first!");
15358 const nativeResponseValue = wasm.TS_CVec_InputZ_free(_res);
15359 // debug statements here
15361 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_ok(struct LDKCoinSelection o);
15363 export function CResult_CoinSelectionNoneZ_ok(o: bigint): bigint {
15364 if(!isWasmInitialized) {
15365 throw new Error("initializeWasm() must be awaited first!");
15367 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_ok(o);
15368 return nativeResponseValue;
15370 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_err(void);
15372 export function CResult_CoinSelectionNoneZ_err(): bigint {
15373 if(!isWasmInitialized) {
15374 throw new Error("initializeWasm() must be awaited first!");
15376 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_err();
15377 return nativeResponseValue;
15379 // bool CResult_CoinSelectionNoneZ_is_ok(const struct LDKCResult_CoinSelectionNoneZ *NONNULL_PTR o);
15381 export function CResult_CoinSelectionNoneZ_is_ok(o: bigint): boolean {
15382 if(!isWasmInitialized) {
15383 throw new Error("initializeWasm() must be awaited first!");
15385 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_is_ok(o);
15386 return nativeResponseValue;
15388 // void CResult_CoinSelectionNoneZ_free(struct LDKCResult_CoinSelectionNoneZ _res);
15390 export function CResult_CoinSelectionNoneZ_free(_res: bigint): void {
15391 if(!isWasmInitialized) {
15392 throw new Error("initializeWasm() must be awaited first!");
15394 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_free(_res);
15395 // debug statements here
15397 // uint64_t CResult_CoinSelectionNoneZ_clone_ptr(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR arg);
15399 export function CResult_CoinSelectionNoneZ_clone_ptr(arg: bigint): bigint {
15400 if(!isWasmInitialized) {
15401 throw new Error("initializeWasm() must be awaited first!");
15403 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_clone_ptr(arg);
15404 return nativeResponseValue;
15406 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_clone(const struct LDKCResult_CoinSelectionNoneZ *NONNULL_PTR orig);
15408 export function CResult_CoinSelectionNoneZ_clone(orig: bigint): bigint {
15409 if(!isWasmInitialized) {
15410 throw new Error("initializeWasm() must be awaited first!");
15412 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_clone(orig);
15413 return nativeResponseValue;
15415 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_ok(struct LDKCVec_UtxoZ o);
15417 export function CResult_CVec_UtxoZNoneZ_ok(o: number): bigint {
15418 if(!isWasmInitialized) {
15419 throw new Error("initializeWasm() must be awaited first!");
15421 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_ok(o);
15422 return nativeResponseValue;
15424 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_err(void);
15426 export function CResult_CVec_UtxoZNoneZ_err(): bigint {
15427 if(!isWasmInitialized) {
15428 throw new Error("initializeWasm() must be awaited first!");
15430 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_err();
15431 return nativeResponseValue;
15433 // bool CResult_CVec_UtxoZNoneZ_is_ok(const struct LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR o);
15435 export function CResult_CVec_UtxoZNoneZ_is_ok(o: bigint): boolean {
15436 if(!isWasmInitialized) {
15437 throw new Error("initializeWasm() must be awaited first!");
15439 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_is_ok(o);
15440 return nativeResponseValue;
15442 // void CResult_CVec_UtxoZNoneZ_free(struct LDKCResult_CVec_UtxoZNoneZ _res);
15444 export function CResult_CVec_UtxoZNoneZ_free(_res: bigint): void {
15445 if(!isWasmInitialized) {
15446 throw new Error("initializeWasm() must be awaited first!");
15448 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_free(_res);
15449 // debug statements here
15451 // uint64_t CResult_CVec_UtxoZNoneZ_clone_ptr(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR arg);
15453 export function CResult_CVec_UtxoZNoneZ_clone_ptr(arg: bigint): bigint {
15454 if(!isWasmInitialized) {
15455 throw new Error("initializeWasm() must be awaited first!");
15457 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_clone_ptr(arg);
15458 return nativeResponseValue;
15460 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_clone(const struct LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR orig);
15462 export function CResult_CVec_UtxoZNoneZ_clone(orig: bigint): bigint {
15463 if(!isWasmInitialized) {
15464 throw new Error("initializeWasm() must be awaited first!");
15466 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_clone(orig);
15467 return nativeResponseValue;
15469 // uint64_t C2Tuple_u64u16Z_clone_ptr(LDKC2Tuple_u64u16Z *NONNULL_PTR arg);
15471 export function C2Tuple_u64u16Z_clone_ptr(arg: bigint): bigint {
15472 if(!isWasmInitialized) {
15473 throw new Error("initializeWasm() must be awaited first!");
15475 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_clone_ptr(arg);
15476 return nativeResponseValue;
15478 // struct LDKC2Tuple_u64u16Z C2Tuple_u64u16Z_clone(const struct LDKC2Tuple_u64u16Z *NONNULL_PTR orig);
15480 export function C2Tuple_u64u16Z_clone(orig: bigint): bigint {
15481 if(!isWasmInitialized) {
15482 throw new Error("initializeWasm() must be awaited first!");
15484 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_clone(orig);
15485 return nativeResponseValue;
15487 // struct LDKC2Tuple_u64u16Z C2Tuple_u64u16Z_new(uint64_t a, uint16_t b);
15489 export function C2Tuple_u64u16Z_new(a: bigint, b: number): bigint {
15490 if(!isWasmInitialized) {
15491 throw new Error("initializeWasm() must be awaited first!");
15493 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_new(a, b);
15494 return nativeResponseValue;
15496 // void C2Tuple_u64u16Z_free(struct LDKC2Tuple_u64u16Z _res);
15498 export function C2Tuple_u64u16Z_free(_res: bigint): void {
15499 if(!isWasmInitialized) {
15500 throw new Error("initializeWasm() must be awaited first!");
15502 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_free(_res);
15503 // debug statements here
15505 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_some(struct LDKC2Tuple_u64u16Z o);
15507 export function COption_C2Tuple_u64u16ZZ_some(o: bigint): bigint {
15508 if(!isWasmInitialized) {
15509 throw new Error("initializeWasm() must be awaited first!");
15511 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_some(o);
15512 return nativeResponseValue;
15514 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_none(void);
15516 export function COption_C2Tuple_u64u16ZZ_none(): bigint {
15517 if(!isWasmInitialized) {
15518 throw new Error("initializeWasm() must be awaited first!");
15520 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_none();
15521 return nativeResponseValue;
15523 // void COption_C2Tuple_u64u16ZZ_free(struct LDKCOption_C2Tuple_u64u16ZZ _res);
15525 export function COption_C2Tuple_u64u16ZZ_free(_res: bigint): void {
15526 if(!isWasmInitialized) {
15527 throw new Error("initializeWasm() must be awaited first!");
15529 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_free(_res);
15530 // debug statements here
15532 // uint64_t COption_C2Tuple_u64u16ZZ_clone_ptr(LDKCOption_C2Tuple_u64u16ZZ *NONNULL_PTR arg);
15534 export function COption_C2Tuple_u64u16ZZ_clone_ptr(arg: bigint): bigint {
15535 if(!isWasmInitialized) {
15536 throw new Error("initializeWasm() must be awaited first!");
15538 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_clone_ptr(arg);
15539 return nativeResponseValue;
15541 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_clone(const struct LDKCOption_C2Tuple_u64u16ZZ *NONNULL_PTR orig);
15543 export function COption_C2Tuple_u64u16ZZ_clone(orig: bigint): bigint {
15544 if(!isWasmInitialized) {
15545 throw new Error("initializeWasm() must be awaited first!");
15547 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_clone(orig);
15548 return nativeResponseValue;
15550 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_some(enum LDKChannelShutdownState o);
15552 export function COption_ChannelShutdownStateZ_some(o: ChannelShutdownState): bigint {
15553 if(!isWasmInitialized) {
15554 throw new Error("initializeWasm() must be awaited first!");
15556 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_some(o);
15557 return nativeResponseValue;
15559 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_none(void);
15561 export function COption_ChannelShutdownStateZ_none(): bigint {
15562 if(!isWasmInitialized) {
15563 throw new Error("initializeWasm() must be awaited first!");
15565 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_none();
15566 return nativeResponseValue;
15568 // void COption_ChannelShutdownStateZ_free(struct LDKCOption_ChannelShutdownStateZ _res);
15570 export function COption_ChannelShutdownStateZ_free(_res: bigint): void {
15571 if(!isWasmInitialized) {
15572 throw new Error("initializeWasm() must be awaited first!");
15574 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_free(_res);
15575 // debug statements here
15577 // uint64_t COption_ChannelShutdownStateZ_clone_ptr(LDKCOption_ChannelShutdownStateZ *NONNULL_PTR arg);
15579 export function COption_ChannelShutdownStateZ_clone_ptr(arg: bigint): bigint {
15580 if(!isWasmInitialized) {
15581 throw new Error("initializeWasm() must be awaited first!");
15583 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone_ptr(arg);
15584 return nativeResponseValue;
15586 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_clone(const struct LDKCOption_ChannelShutdownStateZ *NONNULL_PTR orig);
15588 export function COption_ChannelShutdownStateZ_clone(orig: bigint): bigint {
15589 if(!isWasmInitialized) {
15590 throw new Error("initializeWasm() must be awaited first!");
15592 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone(orig);
15593 return nativeResponseValue;
15595 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
15597 export function CResult_ThirtyTwoBytesAPIErrorZ_ok(o: number): bigint {
15598 if(!isWasmInitialized) {
15599 throw new Error("initializeWasm() must be awaited first!");
15601 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_ok(o);
15602 return nativeResponseValue;
15604 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_err(struct LDKAPIError e);
15606 export function CResult_ThirtyTwoBytesAPIErrorZ_err(e: bigint): bigint {
15607 if(!isWasmInitialized) {
15608 throw new Error("initializeWasm() must be awaited first!");
15610 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_err(e);
15611 return nativeResponseValue;
15613 // bool CResult_ThirtyTwoBytesAPIErrorZ_is_ok(const struct LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR o);
15615 export function CResult_ThirtyTwoBytesAPIErrorZ_is_ok(o: bigint): boolean {
15616 if(!isWasmInitialized) {
15617 throw new Error("initializeWasm() must be awaited first!");
15619 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_is_ok(o);
15620 return nativeResponseValue;
15622 // void CResult_ThirtyTwoBytesAPIErrorZ_free(struct LDKCResult_ThirtyTwoBytesAPIErrorZ _res);
15624 export function CResult_ThirtyTwoBytesAPIErrorZ_free(_res: bigint): void {
15625 if(!isWasmInitialized) {
15626 throw new Error("initializeWasm() must be awaited first!");
15628 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_free(_res);
15629 // debug statements here
15631 // uint64_t CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR arg);
15633 export function CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(arg: bigint): bigint {
15634 if(!isWasmInitialized) {
15635 throw new Error("initializeWasm() must be awaited first!");
15637 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(arg);
15638 return nativeResponseValue;
15640 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_clone(const struct LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR orig);
15642 export function CResult_ThirtyTwoBytesAPIErrorZ_clone(orig: bigint): bigint {
15643 if(!isWasmInitialized) {
15644 throw new Error("initializeWasm() must be awaited first!");
15646 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_clone(orig);
15647 return nativeResponseValue;
15649 // void CVec_RecentPaymentDetailsZ_free(struct LDKCVec_RecentPaymentDetailsZ _res);
15651 export function CVec_RecentPaymentDetailsZ_free(_res: number): void {
15652 if(!isWasmInitialized) {
15653 throw new Error("initializeWasm() must be awaited first!");
15655 const nativeResponseValue = wasm.TS_CVec_RecentPaymentDetailsZ_free(_res);
15656 // debug statements here
15658 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
15660 export function CResult_NonePaymentSendFailureZ_ok(): bigint {
15661 if(!isWasmInitialized) {
15662 throw new Error("initializeWasm() must be awaited first!");
15664 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
15665 return nativeResponseValue;
15667 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
15669 export function CResult_NonePaymentSendFailureZ_err(e: bigint): bigint {
15670 if(!isWasmInitialized) {
15671 throw new Error("initializeWasm() must be awaited first!");
15673 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
15674 return nativeResponseValue;
15676 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
15678 export function CResult_NonePaymentSendFailureZ_is_ok(o: bigint): boolean {
15679 if(!isWasmInitialized) {
15680 throw new Error("initializeWasm() must be awaited first!");
15682 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
15683 return nativeResponseValue;
15685 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
15687 export function CResult_NonePaymentSendFailureZ_free(_res: bigint): void {
15688 if(!isWasmInitialized) {
15689 throw new Error("initializeWasm() must be awaited first!");
15691 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
15692 // debug statements here
15694 // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
15696 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
15697 if(!isWasmInitialized) {
15698 throw new Error("initializeWasm() must be awaited first!");
15700 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
15701 return nativeResponseValue;
15703 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
15705 export function CResult_NonePaymentSendFailureZ_clone(orig: bigint): bigint {
15706 if(!isWasmInitialized) {
15707 throw new Error("initializeWasm() must be awaited first!");
15709 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
15710 return nativeResponseValue;
15712 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_ok(void);
15714 export function CResult_NoneRetryableSendFailureZ_ok(): bigint {
15715 if(!isWasmInitialized) {
15716 throw new Error("initializeWasm() must be awaited first!");
15718 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_ok();
15719 return nativeResponseValue;
15721 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
15723 export function CResult_NoneRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
15724 if(!isWasmInitialized) {
15725 throw new Error("initializeWasm() must be awaited first!");
15727 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_err(e);
15728 return nativeResponseValue;
15730 // bool CResult_NoneRetryableSendFailureZ_is_ok(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR o);
15732 export function CResult_NoneRetryableSendFailureZ_is_ok(o: bigint): boolean {
15733 if(!isWasmInitialized) {
15734 throw new Error("initializeWasm() must be awaited first!");
15736 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_is_ok(o);
15737 return nativeResponseValue;
15739 // void CResult_NoneRetryableSendFailureZ_free(struct LDKCResult_NoneRetryableSendFailureZ _res);
15741 export function CResult_NoneRetryableSendFailureZ_free(_res: bigint): void {
15742 if(!isWasmInitialized) {
15743 throw new Error("initializeWasm() must be awaited first!");
15745 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_free(_res);
15746 // debug statements here
15748 // uint64_t CResult_NoneRetryableSendFailureZ_clone_ptr(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR arg);
15750 export function CResult_NoneRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
15751 if(!isWasmInitialized) {
15752 throw new Error("initializeWasm() must be awaited first!");
15754 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone_ptr(arg);
15755 return nativeResponseValue;
15757 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_clone(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR orig);
15759 export function CResult_NoneRetryableSendFailureZ_clone(orig: bigint): bigint {
15760 if(!isWasmInitialized) {
15761 throw new Error("initializeWasm() must be awaited first!");
15763 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone(orig);
15764 return nativeResponseValue;
15766 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
15768 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(o: number): bigint {
15769 if(!isWasmInitialized) {
15770 throw new Error("initializeWasm() must be awaited first!");
15772 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(o);
15773 return nativeResponseValue;
15775 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
15777 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_err(e: bigint): bigint {
15778 if(!isWasmInitialized) {
15779 throw new Error("initializeWasm() must be awaited first!");
15781 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_err(e);
15782 return nativeResponseValue;
15784 // bool CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(const struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR o);
15786 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(o: bigint): boolean {
15787 if(!isWasmInitialized) {
15788 throw new Error("initializeWasm() must be awaited first!");
15790 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(o);
15791 return nativeResponseValue;
15793 // void CResult_ThirtyTwoBytesPaymentSendFailureZ_free(struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ _res);
15795 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_free(_res: bigint): void {
15796 if(!isWasmInitialized) {
15797 throw new Error("initializeWasm() must be awaited first!");
15799 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_free(_res);
15800 // debug statements here
15802 // uint64_t CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR arg);
15804 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
15805 if(!isWasmInitialized) {
15806 throw new Error("initializeWasm() must be awaited first!");
15808 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(arg);
15809 return nativeResponseValue;
15811 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(const struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR orig);
15813 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(orig: bigint): bigint {
15814 if(!isWasmInitialized) {
15815 throw new Error("initializeWasm() must be awaited first!");
15817 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(orig);
15818 return nativeResponseValue;
15820 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(struct LDKThirtyTwoBytes o);
15822 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(o: number): bigint {
15823 if(!isWasmInitialized) {
15824 throw new Error("initializeWasm() must be awaited first!");
15826 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(o);
15827 return nativeResponseValue;
15829 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
15831 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
15832 if(!isWasmInitialized) {
15833 throw new Error("initializeWasm() must be awaited first!");
15835 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_err(e);
15836 return nativeResponseValue;
15838 // bool CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(const struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR o);
15840 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(o: bigint): boolean {
15841 if(!isWasmInitialized) {
15842 throw new Error("initializeWasm() must be awaited first!");
15844 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(o);
15845 return nativeResponseValue;
15847 // void CResult_ThirtyTwoBytesRetryableSendFailureZ_free(struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ _res);
15849 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_free(_res: bigint): void {
15850 if(!isWasmInitialized) {
15851 throw new Error("initializeWasm() must be awaited first!");
15853 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_free(_res);
15854 // debug statements here
15856 // uint64_t CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR arg);
15858 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
15859 if(!isWasmInitialized) {
15860 throw new Error("initializeWasm() must be awaited first!");
15862 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(arg);
15863 return nativeResponseValue;
15865 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(const struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR orig);
15867 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(orig: bigint): bigint {
15868 if(!isWasmInitialized) {
15869 throw new Error("initializeWasm() must be awaited first!");
15871 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(orig);
15872 return nativeResponseValue;
15874 // uint64_t C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR arg);
15876 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(arg: bigint): bigint {
15877 if(!isWasmInitialized) {
15878 throw new Error("initializeWasm() must be awaited first!");
15880 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(arg);
15881 return nativeResponseValue;
15883 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR orig);
15885 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(orig: bigint): bigint {
15886 if(!isWasmInitialized) {
15887 throw new Error("initializeWasm() must be awaited first!");
15889 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(orig);
15890 return nativeResponseValue;
15892 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
15894 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(a: number, b: number): bigint {
15895 if(!isWasmInitialized) {
15896 throw new Error("initializeWasm() must be awaited first!");
15898 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(a, b);
15899 return nativeResponseValue;
15901 // void C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ _res);
15903 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(_res: bigint): void {
15904 if(!isWasmInitialized) {
15905 throw new Error("initializeWasm() must be awaited first!");
15907 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(_res);
15908 // debug statements here
15910 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o);
15912 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(o: bigint): bigint {
15913 if(!isWasmInitialized) {
15914 throw new Error("initializeWasm() must be awaited first!");
15916 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(o);
15917 return nativeResponseValue;
15919 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
15921 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(e: bigint): bigint {
15922 if(!isWasmInitialized) {
15923 throw new Error("initializeWasm() must be awaited first!");
15925 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(e);
15926 return nativeResponseValue;
15928 // bool CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR o);
15930 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(o: bigint): boolean {
15931 if(!isWasmInitialized) {
15932 throw new Error("initializeWasm() must be awaited first!");
15934 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(o);
15935 return nativeResponseValue;
15937 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ _res);
15939 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(_res: bigint): void {
15940 if(!isWasmInitialized) {
15941 throw new Error("initializeWasm() must be awaited first!");
15943 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(_res);
15944 // debug statements here
15946 // uint64_t CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR arg);
15948 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
15949 if(!isWasmInitialized) {
15950 throw new Error("initializeWasm() must be awaited first!");
15952 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(arg);
15953 return nativeResponseValue;
15955 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR orig);
15957 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(orig: bigint): bigint {
15958 if(!isWasmInitialized) {
15959 throw new Error("initializeWasm() must be awaited first!");
15961 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(orig);
15962 return nativeResponseValue;
15964 // void CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ _res);
15966 export function CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(_res: number): void {
15967 if(!isWasmInitialized) {
15968 throw new Error("initializeWasm() must be awaited first!");
15970 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(_res);
15971 // debug statements here
15973 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ o);
15975 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(o: number): bigint {
15976 if(!isWasmInitialized) {
15977 throw new Error("initializeWasm() must be awaited first!");
15979 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(o);
15980 return nativeResponseValue;
15982 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(struct LDKProbeSendFailure e);
15984 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(e: bigint): bigint {
15985 if(!isWasmInitialized) {
15986 throw new Error("initializeWasm() must be awaited first!");
15988 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(e);
15989 return nativeResponseValue;
15991 // bool CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR o);
15993 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(o: bigint): boolean {
15994 if(!isWasmInitialized) {
15995 throw new Error("initializeWasm() must be awaited first!");
15997 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(o);
15998 return nativeResponseValue;
16000 // void CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ _res);
16002 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(_res: bigint): void {
16003 if(!isWasmInitialized) {
16004 throw new Error("initializeWasm() must be awaited first!");
16006 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(_res);
16007 // debug statements here
16009 // uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR arg);
16011 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(arg: bigint): bigint {
16012 if(!isWasmInitialized) {
16013 throw new Error("initializeWasm() must be awaited first!");
16015 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(arg);
16016 return nativeResponseValue;
16018 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR orig);
16020 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(orig: bigint): bigint {
16021 if(!isWasmInitialized) {
16022 throw new Error("initializeWasm() must be awaited first!");
16024 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(orig);
16025 return nativeResponseValue;
16027 // uint64_t C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR arg);
16029 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(arg: bigint): bigint {
16030 if(!isWasmInitialized) {
16031 throw new Error("initializeWasm() must be awaited first!");
16033 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(arg);
16034 return nativeResponseValue;
16036 // struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR orig);
16038 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(orig: bigint): bigint {
16039 if(!isWasmInitialized) {
16040 throw new Error("initializeWasm() must be awaited first!");
16042 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(orig);
16043 return nativeResponseValue;
16045 // struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ C2Tuple_ThirtyTwoBytesPublicKeyZ_new(struct LDKThirtyTwoBytes a, struct LDKPublicKey b);
16047 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_new(a: number, b: number): bigint {
16048 if(!isWasmInitialized) {
16049 throw new Error("initializeWasm() must be awaited first!");
16051 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_new(a, b);
16052 return nativeResponseValue;
16054 // void C2Tuple_ThirtyTwoBytesPublicKeyZ_free(struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ _res);
16056 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_free(_res: bigint): void {
16057 if(!isWasmInitialized) {
16058 throw new Error("initializeWasm() must be awaited first!");
16060 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_free(_res);
16061 // debug statements here
16063 // void CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ _res);
16065 export function CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(_res: number): void {
16066 if(!isWasmInitialized) {
16067 throw new Error("initializeWasm() must be awaited first!");
16069 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(_res);
16070 // debug statements here
16072 // struct LDKCOption_StrZ COption_StrZ_some(struct LDKStr o);
16074 export function COption_StrZ_some(o: number): bigint {
16075 if(!isWasmInitialized) {
16076 throw new Error("initializeWasm() must be awaited first!");
16078 const nativeResponseValue = wasm.TS_COption_StrZ_some(o);
16079 return nativeResponseValue;
16081 // struct LDKCOption_StrZ COption_StrZ_none(void);
16083 export function COption_StrZ_none(): bigint {
16084 if(!isWasmInitialized) {
16085 throw new Error("initializeWasm() must be awaited first!");
16087 const nativeResponseValue = wasm.TS_COption_StrZ_none();
16088 return nativeResponseValue;
16090 // void COption_StrZ_free(struct LDKCOption_StrZ _res);
16092 export function COption_StrZ_free(_res: bigint): void {
16093 if(!isWasmInitialized) {
16094 throw new Error("initializeWasm() must be awaited first!");
16096 const nativeResponseValue = wasm.TS_COption_StrZ_free(_res);
16097 // debug statements here
16099 // uint64_t COption_StrZ_clone_ptr(LDKCOption_StrZ *NONNULL_PTR arg);
16101 export function COption_StrZ_clone_ptr(arg: bigint): bigint {
16102 if(!isWasmInitialized) {
16103 throw new Error("initializeWasm() must be awaited first!");
16105 const nativeResponseValue = wasm.TS_COption_StrZ_clone_ptr(arg);
16106 return nativeResponseValue;
16108 // struct LDKCOption_StrZ COption_StrZ_clone(const struct LDKCOption_StrZ *NONNULL_PTR orig);
16110 export function COption_StrZ_clone(orig: bigint): bigint {
16111 if(!isWasmInitialized) {
16112 throw new Error("initializeWasm() must be awaited first!");
16114 const nativeResponseValue = wasm.TS_COption_StrZ_clone(orig);
16115 return nativeResponseValue;
16117 // struct LDKCResult_NoneBolt12SemanticErrorZ CResult_NoneBolt12SemanticErrorZ_ok(void);
16119 export function CResult_NoneBolt12SemanticErrorZ_ok(): bigint {
16120 if(!isWasmInitialized) {
16121 throw new Error("initializeWasm() must be awaited first!");
16123 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_ok();
16124 return nativeResponseValue;
16126 // struct LDKCResult_NoneBolt12SemanticErrorZ CResult_NoneBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
16128 export function CResult_NoneBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
16129 if(!isWasmInitialized) {
16130 throw new Error("initializeWasm() must be awaited first!");
16132 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_err(e);
16133 return nativeResponseValue;
16135 // bool CResult_NoneBolt12SemanticErrorZ_is_ok(const struct LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR o);
16137 export function CResult_NoneBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
16138 if(!isWasmInitialized) {
16139 throw new Error("initializeWasm() must be awaited first!");
16141 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_is_ok(o);
16142 return nativeResponseValue;
16144 // void CResult_NoneBolt12SemanticErrorZ_free(struct LDKCResult_NoneBolt12SemanticErrorZ _res);
16146 export function CResult_NoneBolt12SemanticErrorZ_free(_res: bigint): void {
16147 if(!isWasmInitialized) {
16148 throw new Error("initializeWasm() must be awaited first!");
16150 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_free(_res);
16151 // debug statements here
16153 // uint64_t CResult_NoneBolt12SemanticErrorZ_clone_ptr(LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR arg);
16155 export function CResult_NoneBolt12SemanticErrorZ_clone_ptr(arg: bigint): bigint {
16156 if(!isWasmInitialized) {
16157 throw new Error("initializeWasm() must be awaited first!");
16159 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_clone_ptr(arg);
16160 return nativeResponseValue;
16162 // struct LDKCResult_NoneBolt12SemanticErrorZ CResult_NoneBolt12SemanticErrorZ_clone(const struct LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR orig);
16164 export function CResult_NoneBolt12SemanticErrorZ_clone(orig: bigint): bigint {
16165 if(!isWasmInitialized) {
16166 throw new Error("initializeWasm() must be awaited first!");
16168 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_clone(orig);
16169 return nativeResponseValue;
16171 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o);
16173 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(o: bigint): bigint {
16174 if(!isWasmInitialized) {
16175 throw new Error("initializeWasm() must be awaited first!");
16177 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(o);
16178 return nativeResponseValue;
16180 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err(void);
16182 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err(): bigint {
16183 if(!isWasmInitialized) {
16184 throw new Error("initializeWasm() must be awaited first!");
16186 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err();
16187 return nativeResponseValue;
16189 // bool CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR o);
16191 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(o: bigint): boolean {
16192 if(!isWasmInitialized) {
16193 throw new Error("initializeWasm() must be awaited first!");
16195 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(o);
16196 return nativeResponseValue;
16198 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ _res);
16200 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(_res: bigint): void {
16201 if(!isWasmInitialized) {
16202 throw new Error("initializeWasm() must be awaited first!");
16204 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(_res);
16205 // debug statements here
16207 // uint64_t CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR arg);
16209 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(arg: bigint): bigint {
16210 if(!isWasmInitialized) {
16211 throw new Error("initializeWasm() must be awaited first!");
16213 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(arg);
16214 return nativeResponseValue;
16216 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR orig);
16218 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(orig: bigint): bigint {
16219 if(!isWasmInitialized) {
16220 throw new Error("initializeWasm() must be awaited first!");
16222 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(orig);
16223 return nativeResponseValue;
16225 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_some(struct LDKOffersMessage o);
16227 export function COption_OffersMessageZ_some(o: bigint): bigint {
16228 if(!isWasmInitialized) {
16229 throw new Error("initializeWasm() must be awaited first!");
16231 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_some(o);
16232 return nativeResponseValue;
16234 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_none(void);
16236 export function COption_OffersMessageZ_none(): bigint {
16237 if(!isWasmInitialized) {
16238 throw new Error("initializeWasm() must be awaited first!");
16240 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_none();
16241 return nativeResponseValue;
16243 // void COption_OffersMessageZ_free(struct LDKCOption_OffersMessageZ _res);
16245 export function COption_OffersMessageZ_free(_res: bigint): void {
16246 if(!isWasmInitialized) {
16247 throw new Error("initializeWasm() must be awaited first!");
16249 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_free(_res);
16250 // debug statements here
16252 // uint64_t COption_OffersMessageZ_clone_ptr(LDKCOption_OffersMessageZ *NONNULL_PTR arg);
16254 export function COption_OffersMessageZ_clone_ptr(arg: bigint): bigint {
16255 if(!isWasmInitialized) {
16256 throw new Error("initializeWasm() must be awaited first!");
16258 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_clone_ptr(arg);
16259 return nativeResponseValue;
16261 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_clone(const struct LDKCOption_OffersMessageZ *NONNULL_PTR orig);
16263 export function COption_OffersMessageZ_clone(orig: bigint): bigint {
16264 if(!isWasmInitialized) {
16265 throw new Error("initializeWasm() must be awaited first!");
16267 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_clone(orig);
16268 return nativeResponseValue;
16270 // uint64_t C3Tuple_OffersMessageDestinationBlindedPathZ_clone_ptr(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR arg);
16272 export function C3Tuple_OffersMessageDestinationBlindedPathZ_clone_ptr(arg: bigint): bigint {
16273 if(!isWasmInitialized) {
16274 throw new Error("initializeWasm() must be awaited first!");
16276 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_clone_ptr(arg);
16277 return nativeResponseValue;
16279 // struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ C3Tuple_OffersMessageDestinationBlindedPathZ_clone(const struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR orig);
16281 export function C3Tuple_OffersMessageDestinationBlindedPathZ_clone(orig: bigint): bigint {
16282 if(!isWasmInitialized) {
16283 throw new Error("initializeWasm() must be awaited first!");
16285 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_clone(orig);
16286 return nativeResponseValue;
16288 // struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ C3Tuple_OffersMessageDestinationBlindedPathZ_new(struct LDKOffersMessage a, struct LDKDestination b, struct LDKBlindedPath c);
16290 export function C3Tuple_OffersMessageDestinationBlindedPathZ_new(a: bigint, b: bigint, c: bigint): bigint {
16291 if(!isWasmInitialized) {
16292 throw new Error("initializeWasm() must be awaited first!");
16294 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_new(a, b, c);
16295 return nativeResponseValue;
16297 // void C3Tuple_OffersMessageDestinationBlindedPathZ_free(struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ _res);
16299 export function C3Tuple_OffersMessageDestinationBlindedPathZ_free(_res: bigint): void {
16300 if(!isWasmInitialized) {
16301 throw new Error("initializeWasm() must be awaited first!");
16303 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_free(_res);
16304 // debug statements here
16306 // void CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(struct LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ _res);
16308 export function CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(_res: number): void {
16309 if(!isWasmInitialized) {
16310 throw new Error("initializeWasm() must be awaited first!");
16312 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(_res);
16313 // debug statements here
16315 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
16317 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
16318 if(!isWasmInitialized) {
16319 throw new Error("initializeWasm() must be awaited first!");
16321 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
16322 return nativeResponseValue;
16324 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
16326 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
16327 if(!isWasmInitialized) {
16328 throw new Error("initializeWasm() must be awaited first!");
16330 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
16331 return nativeResponseValue;
16333 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
16335 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
16336 if(!isWasmInitialized) {
16337 throw new Error("initializeWasm() must be awaited first!");
16339 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
16340 return nativeResponseValue;
16342 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
16344 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
16345 if(!isWasmInitialized) {
16346 throw new Error("initializeWasm() must be awaited first!");
16348 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
16349 // debug statements here
16351 // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
16353 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16354 if(!isWasmInitialized) {
16355 throw new Error("initializeWasm() must be awaited first!");
16357 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
16358 return nativeResponseValue;
16360 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
16362 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
16363 if(!isWasmInitialized) {
16364 throw new Error("initializeWasm() must be awaited first!");
16366 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
16367 return nativeResponseValue;
16369 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
16371 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
16372 if(!isWasmInitialized) {
16373 throw new Error("initializeWasm() must be awaited first!");
16375 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
16376 return nativeResponseValue;
16378 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
16380 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
16381 if(!isWasmInitialized) {
16382 throw new Error("initializeWasm() must be awaited first!");
16384 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
16385 return nativeResponseValue;
16387 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
16389 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
16390 if(!isWasmInitialized) {
16391 throw new Error("initializeWasm() must be awaited first!");
16393 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
16394 return nativeResponseValue;
16396 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
16398 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
16399 if(!isWasmInitialized) {
16400 throw new Error("initializeWasm() must be awaited first!");
16402 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
16403 // debug statements here
16405 // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
16407 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16408 if(!isWasmInitialized) {
16409 throw new Error("initializeWasm() must be awaited first!");
16411 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
16412 return nativeResponseValue;
16414 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
16416 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
16417 if(!isWasmInitialized) {
16418 throw new Error("initializeWasm() must be awaited first!");
16420 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
16421 return nativeResponseValue;
16423 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
16425 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
16426 if(!isWasmInitialized) {
16427 throw new Error("initializeWasm() must be awaited first!");
16429 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
16430 return nativeResponseValue;
16432 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
16434 export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
16435 if(!isWasmInitialized) {
16436 throw new Error("initializeWasm() must be awaited first!");
16438 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
16439 return nativeResponseValue;
16441 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
16443 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
16444 if(!isWasmInitialized) {
16445 throw new Error("initializeWasm() must be awaited first!");
16447 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
16448 return nativeResponseValue;
16450 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
16452 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
16453 if(!isWasmInitialized) {
16454 throw new Error("initializeWasm() must be awaited first!");
16456 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
16457 // debug statements here
16459 // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
16461 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16462 if(!isWasmInitialized) {
16463 throw new Error("initializeWasm() must be awaited first!");
16465 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
16466 return nativeResponseValue;
16468 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
16470 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
16471 if(!isWasmInitialized) {
16472 throw new Error("initializeWasm() must be awaited first!");
16474 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
16475 return nativeResponseValue;
16477 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
16479 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: bigint): bigint {
16480 if(!isWasmInitialized) {
16481 throw new Error("initializeWasm() must be awaited first!");
16483 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
16484 return nativeResponseValue;
16486 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
16488 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: bigint): bigint {
16489 if(!isWasmInitialized) {
16490 throw new Error("initializeWasm() must be awaited first!");
16492 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
16493 return nativeResponseValue;
16495 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
16497 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: bigint): boolean {
16498 if(!isWasmInitialized) {
16499 throw new Error("initializeWasm() must be awaited first!");
16501 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
16502 return nativeResponseValue;
16504 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
16506 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: bigint): void {
16507 if(!isWasmInitialized) {
16508 throw new Error("initializeWasm() must be awaited first!");
16510 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
16511 // debug statements here
16513 // uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
16515 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16516 if(!isWasmInitialized) {
16517 throw new Error("initializeWasm() must be awaited first!");
16519 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
16520 return nativeResponseValue;
16522 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
16524 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: bigint): bigint {
16525 if(!isWasmInitialized) {
16526 throw new Error("initializeWasm() must be awaited first!");
16528 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
16529 return nativeResponseValue;
16531 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_ok(enum LDKChannelShutdownState o);
16533 export function CResult_ChannelShutdownStateDecodeErrorZ_ok(o: ChannelShutdownState): bigint {
16534 if(!isWasmInitialized) {
16535 throw new Error("initializeWasm() must be awaited first!");
16537 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_ok(o);
16538 return nativeResponseValue;
16540 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_err(struct LDKDecodeError e);
16542 export function CResult_ChannelShutdownStateDecodeErrorZ_err(e: bigint): bigint {
16543 if(!isWasmInitialized) {
16544 throw new Error("initializeWasm() must be awaited first!");
16546 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_err(e);
16547 return nativeResponseValue;
16549 // bool CResult_ChannelShutdownStateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR o);
16551 export function CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o: bigint): boolean {
16552 if(!isWasmInitialized) {
16553 throw new Error("initializeWasm() must be awaited first!");
16555 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o);
16556 return nativeResponseValue;
16558 // void CResult_ChannelShutdownStateDecodeErrorZ_free(struct LDKCResult_ChannelShutdownStateDecodeErrorZ _res);
16560 export function CResult_ChannelShutdownStateDecodeErrorZ_free(_res: bigint): void {
16561 if(!isWasmInitialized) {
16562 throw new Error("initializeWasm() must be awaited first!");
16564 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_free(_res);
16565 // debug statements here
16567 // uint64_t CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR arg);
16569 export function CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16570 if(!isWasmInitialized) {
16571 throw new Error("initializeWasm() must be awaited first!");
16573 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg);
16574 return nativeResponseValue;
16576 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_clone(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR orig);
16578 export function CResult_ChannelShutdownStateDecodeErrorZ_clone(orig: bigint): bigint {
16579 if(!isWasmInitialized) {
16580 throw new Error("initializeWasm() must be awaited first!");
16582 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone(orig);
16583 return nativeResponseValue;
16585 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
16587 export function CVec_ChannelMonitorZ_free(_res: number): void {
16588 if(!isWasmInitialized) {
16589 throw new Error("initializeWasm() must be awaited first!");
16591 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
16592 // debug statements here
16594 // struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ C2Tuple_ThirtyTwoBytesChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
16596 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_new(a: number, b: bigint): bigint {
16597 if(!isWasmInitialized) {
16598 throw new Error("initializeWasm() must be awaited first!");
16600 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_new(a, b);
16601 return nativeResponseValue;
16603 // void C2Tuple_ThirtyTwoBytesChannelManagerZ_free(struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ _res);
16605 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_free(_res: bigint): void {
16606 if(!isWasmInitialized) {
16607 throw new Error("initializeWasm() must be awaited first!");
16609 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_free(_res);
16610 // debug statements here
16612 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ o);
16614 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(o: bigint): bigint {
16615 if(!isWasmInitialized) {
16616 throw new Error("initializeWasm() must be awaited first!");
16618 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(o);
16619 return nativeResponseValue;
16621 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
16623 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(e: bigint): bigint {
16624 if(!isWasmInitialized) {
16625 throw new Error("initializeWasm() must be awaited first!");
16627 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(e);
16628 return nativeResponseValue;
16630 // bool CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR o);
16632 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(o: bigint): boolean {
16633 if(!isWasmInitialized) {
16634 throw new Error("initializeWasm() must be awaited first!");
16636 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(o);
16637 return nativeResponseValue;
16639 // void CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ _res);
16641 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(_res: bigint): void {
16642 if(!isWasmInitialized) {
16643 throw new Error("initializeWasm() must be awaited first!");
16645 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(_res);
16646 // debug statements here
16648 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_ok(struct LDKMaxDustHTLCExposure o);
16650 export function CResult_MaxDustHTLCExposureDecodeErrorZ_ok(o: bigint): bigint {
16651 if(!isWasmInitialized) {
16652 throw new Error("initializeWasm() must be awaited first!");
16654 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_ok(o);
16655 return nativeResponseValue;
16657 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_err(struct LDKDecodeError e);
16659 export function CResult_MaxDustHTLCExposureDecodeErrorZ_err(e: bigint): bigint {
16660 if(!isWasmInitialized) {
16661 throw new Error("initializeWasm() must be awaited first!");
16663 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_err(e);
16664 return nativeResponseValue;
16666 // bool CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(const struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR o);
16668 export function CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(o: bigint): boolean {
16669 if(!isWasmInitialized) {
16670 throw new Error("initializeWasm() must be awaited first!");
16672 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(o);
16673 return nativeResponseValue;
16675 // void CResult_MaxDustHTLCExposureDecodeErrorZ_free(struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ _res);
16677 export function CResult_MaxDustHTLCExposureDecodeErrorZ_free(_res: bigint): void {
16678 if(!isWasmInitialized) {
16679 throw new Error("initializeWasm() must be awaited first!");
16681 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_free(_res);
16682 // debug statements here
16684 // uint64_t CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR arg);
16686 export function CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16687 if(!isWasmInitialized) {
16688 throw new Error("initializeWasm() must be awaited first!");
16690 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(arg);
16691 return nativeResponseValue;
16693 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_clone(const struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR orig);
16695 export function CResult_MaxDustHTLCExposureDecodeErrorZ_clone(orig: bigint): bigint {
16696 if(!isWasmInitialized) {
16697 throw new Error("initializeWasm() must be awaited first!");
16699 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone(orig);
16700 return nativeResponseValue;
16702 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
16704 export function CResult_ChannelConfigDecodeErrorZ_ok(o: bigint): bigint {
16705 if(!isWasmInitialized) {
16706 throw new Error("initializeWasm() must be awaited first!");
16708 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
16709 return nativeResponseValue;
16711 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
16713 export function CResult_ChannelConfigDecodeErrorZ_err(e: bigint): bigint {
16714 if(!isWasmInitialized) {
16715 throw new Error("initializeWasm() must be awaited first!");
16717 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
16718 return nativeResponseValue;
16720 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
16722 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: bigint): boolean {
16723 if(!isWasmInitialized) {
16724 throw new Error("initializeWasm() must be awaited first!");
16726 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
16727 return nativeResponseValue;
16729 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
16731 export function CResult_ChannelConfigDecodeErrorZ_free(_res: bigint): void {
16732 if(!isWasmInitialized) {
16733 throw new Error("initializeWasm() must be awaited first!");
16735 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
16736 // debug statements here
16738 // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
16740 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16741 if(!isWasmInitialized) {
16742 throw new Error("initializeWasm() must be awaited first!");
16744 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
16745 return nativeResponseValue;
16747 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
16749 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: bigint): bigint {
16750 if(!isWasmInitialized) {
16751 throw new Error("initializeWasm() must be awaited first!");
16753 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
16754 return nativeResponseValue;
16756 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_some(struct LDKMaxDustHTLCExposure o);
16758 export function COption_MaxDustHTLCExposureZ_some(o: bigint): bigint {
16759 if(!isWasmInitialized) {
16760 throw new Error("initializeWasm() must be awaited first!");
16762 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_some(o);
16763 return nativeResponseValue;
16765 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_none(void);
16767 export function COption_MaxDustHTLCExposureZ_none(): bigint {
16768 if(!isWasmInitialized) {
16769 throw new Error("initializeWasm() must be awaited first!");
16771 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_none();
16772 return nativeResponseValue;
16774 // void COption_MaxDustHTLCExposureZ_free(struct LDKCOption_MaxDustHTLCExposureZ _res);
16776 export function COption_MaxDustHTLCExposureZ_free(_res: bigint): void {
16777 if(!isWasmInitialized) {
16778 throw new Error("initializeWasm() must be awaited first!");
16780 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_free(_res);
16781 // debug statements here
16783 // uint64_t COption_MaxDustHTLCExposureZ_clone_ptr(LDKCOption_MaxDustHTLCExposureZ *NONNULL_PTR arg);
16785 export function COption_MaxDustHTLCExposureZ_clone_ptr(arg: bigint): bigint {
16786 if(!isWasmInitialized) {
16787 throw new Error("initializeWasm() must be awaited first!");
16789 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_clone_ptr(arg);
16790 return nativeResponseValue;
16792 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_clone(const struct LDKCOption_MaxDustHTLCExposureZ *NONNULL_PTR orig);
16794 export function COption_MaxDustHTLCExposureZ_clone(orig: bigint): bigint {
16795 if(!isWasmInitialized) {
16796 throw new Error("initializeWasm() must be awaited first!");
16798 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_clone(orig);
16799 return nativeResponseValue;
16801 // struct LDKCOption_APIErrorZ COption_APIErrorZ_some(struct LDKAPIError o);
16803 export function COption_APIErrorZ_some(o: bigint): bigint {
16804 if(!isWasmInitialized) {
16805 throw new Error("initializeWasm() must be awaited first!");
16807 const nativeResponseValue = wasm.TS_COption_APIErrorZ_some(o);
16808 return nativeResponseValue;
16810 // struct LDKCOption_APIErrorZ COption_APIErrorZ_none(void);
16812 export function COption_APIErrorZ_none(): bigint {
16813 if(!isWasmInitialized) {
16814 throw new Error("initializeWasm() must be awaited first!");
16816 const nativeResponseValue = wasm.TS_COption_APIErrorZ_none();
16817 return nativeResponseValue;
16819 // void COption_APIErrorZ_free(struct LDKCOption_APIErrorZ _res);
16821 export function COption_APIErrorZ_free(_res: bigint): void {
16822 if(!isWasmInitialized) {
16823 throw new Error("initializeWasm() must be awaited first!");
16825 const nativeResponseValue = wasm.TS_COption_APIErrorZ_free(_res);
16826 // debug statements here
16828 // uint64_t COption_APIErrorZ_clone_ptr(LDKCOption_APIErrorZ *NONNULL_PTR arg);
16830 export function COption_APIErrorZ_clone_ptr(arg: bigint): bigint {
16831 if(!isWasmInitialized) {
16832 throw new Error("initializeWasm() must be awaited first!");
16834 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone_ptr(arg);
16835 return nativeResponseValue;
16837 // struct LDKCOption_APIErrorZ COption_APIErrorZ_clone(const struct LDKCOption_APIErrorZ *NONNULL_PTR orig);
16839 export function COption_APIErrorZ_clone(orig: bigint): bigint {
16840 if(!isWasmInitialized) {
16841 throw new Error("initializeWasm() must be awaited first!");
16843 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone(orig);
16844 return nativeResponseValue;
16846 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_ok(struct LDKCOption_APIErrorZ o);
16848 export function CResult_COption_APIErrorZDecodeErrorZ_ok(o: bigint): bigint {
16849 if(!isWasmInitialized) {
16850 throw new Error("initializeWasm() must be awaited first!");
16852 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_ok(o);
16853 return nativeResponseValue;
16855 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_err(struct LDKDecodeError e);
16857 export function CResult_COption_APIErrorZDecodeErrorZ_err(e: bigint): bigint {
16858 if(!isWasmInitialized) {
16859 throw new Error("initializeWasm() must be awaited first!");
16861 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_err(e);
16862 return nativeResponseValue;
16864 // bool CResult_COption_APIErrorZDecodeErrorZ_is_ok(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR o);
16866 export function CResult_COption_APIErrorZDecodeErrorZ_is_ok(o: bigint): boolean {
16867 if(!isWasmInitialized) {
16868 throw new Error("initializeWasm() must be awaited first!");
16870 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok(o);
16871 return nativeResponseValue;
16873 // void CResult_COption_APIErrorZDecodeErrorZ_free(struct LDKCResult_COption_APIErrorZDecodeErrorZ _res);
16875 export function CResult_COption_APIErrorZDecodeErrorZ_free(_res: bigint): void {
16876 if(!isWasmInitialized) {
16877 throw new Error("initializeWasm() must be awaited first!");
16879 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_free(_res);
16880 // debug statements here
16882 // uint64_t CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR arg);
16884 export function CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16885 if(!isWasmInitialized) {
16886 throw new Error("initializeWasm() must be awaited first!");
16888 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg);
16889 return nativeResponseValue;
16891 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_clone(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR orig);
16893 export function CResult_COption_APIErrorZDecodeErrorZ_clone(orig: bigint): bigint {
16894 if(!isWasmInitialized) {
16895 throw new Error("initializeWasm() must be awaited first!");
16897 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone(orig);
16898 return nativeResponseValue;
16900 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
16902 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: bigint): bigint {
16903 if(!isWasmInitialized) {
16904 throw new Error("initializeWasm() must be awaited first!");
16906 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
16907 return nativeResponseValue;
16909 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
16911 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: bigint): bigint {
16912 if(!isWasmInitialized) {
16913 throw new Error("initializeWasm() must be awaited first!");
16915 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
16916 return nativeResponseValue;
16918 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
16920 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
16921 if(!isWasmInitialized) {
16922 throw new Error("initializeWasm() must be awaited first!");
16924 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
16925 return nativeResponseValue;
16927 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
16929 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: bigint): void {
16930 if(!isWasmInitialized) {
16931 throw new Error("initializeWasm() must be awaited first!");
16933 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
16934 // debug statements here
16936 // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
16938 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16939 if(!isWasmInitialized) {
16940 throw new Error("initializeWasm() must be awaited first!");
16942 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
16943 return nativeResponseValue;
16945 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
16947 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: bigint): bigint {
16948 if(!isWasmInitialized) {
16949 throw new Error("initializeWasm() must be awaited first!");
16951 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
16952 return nativeResponseValue;
16954 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
16956 export function COption_MonitorEventZ_some(o: bigint): bigint {
16957 if(!isWasmInitialized) {
16958 throw new Error("initializeWasm() must be awaited first!");
16960 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
16961 return nativeResponseValue;
16963 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
16965 export function COption_MonitorEventZ_none(): bigint {
16966 if(!isWasmInitialized) {
16967 throw new Error("initializeWasm() must be awaited first!");
16969 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
16970 return nativeResponseValue;
16972 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
16974 export function COption_MonitorEventZ_free(_res: bigint): void {
16975 if(!isWasmInitialized) {
16976 throw new Error("initializeWasm() must be awaited first!");
16978 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
16979 // debug statements here
16981 // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
16983 export function COption_MonitorEventZ_clone_ptr(arg: bigint): bigint {
16984 if(!isWasmInitialized) {
16985 throw new Error("initializeWasm() must be awaited first!");
16987 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
16988 return nativeResponseValue;
16990 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
16992 export function COption_MonitorEventZ_clone(orig: bigint): bigint {
16993 if(!isWasmInitialized) {
16994 throw new Error("initializeWasm() must be awaited first!");
16996 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
16997 return nativeResponseValue;
16999 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
17001 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: bigint): bigint {
17002 if(!isWasmInitialized) {
17003 throw new Error("initializeWasm() must be awaited first!");
17005 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
17006 return nativeResponseValue;
17008 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
17010 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: bigint): bigint {
17011 if(!isWasmInitialized) {
17012 throw new Error("initializeWasm() must be awaited first!");
17014 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
17015 return nativeResponseValue;
17017 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
17019 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: bigint): boolean {
17020 if(!isWasmInitialized) {
17021 throw new Error("initializeWasm() must be awaited first!");
17023 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
17024 return nativeResponseValue;
17026 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
17028 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: bigint): void {
17029 if(!isWasmInitialized) {
17030 throw new Error("initializeWasm() must be awaited first!");
17032 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
17033 // debug statements here
17035 // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
17037 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17038 if(!isWasmInitialized) {
17039 throw new Error("initializeWasm() must be awaited first!");
17041 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
17042 return nativeResponseValue;
17044 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
17046 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: bigint): bigint {
17047 if(!isWasmInitialized) {
17048 throw new Error("initializeWasm() must be awaited first!");
17050 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
17051 return nativeResponseValue;
17053 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
17055 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: bigint): bigint {
17056 if(!isWasmInitialized) {
17057 throw new Error("initializeWasm() must be awaited first!");
17059 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
17060 return nativeResponseValue;
17062 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
17064 export function CResult_HTLCUpdateDecodeErrorZ_err(e: bigint): bigint {
17065 if(!isWasmInitialized) {
17066 throw new Error("initializeWasm() must be awaited first!");
17068 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
17069 return nativeResponseValue;
17071 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
17073 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
17074 if(!isWasmInitialized) {
17075 throw new Error("initializeWasm() must be awaited first!");
17077 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
17078 return nativeResponseValue;
17080 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
17082 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: bigint): void {
17083 if(!isWasmInitialized) {
17084 throw new Error("initializeWasm() must be awaited first!");
17086 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
17087 // debug statements here
17089 // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
17091 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17092 if(!isWasmInitialized) {
17093 throw new Error("initializeWasm() must be awaited first!");
17095 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
17096 return nativeResponseValue;
17098 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
17100 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: bigint): bigint {
17101 if(!isWasmInitialized) {
17102 throw new Error("initializeWasm() must be awaited first!");
17104 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
17105 return nativeResponseValue;
17107 // uint64_t C2Tuple_OutPointCVec_u8ZZ_clone_ptr(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR arg);
17109 export function C2Tuple_OutPointCVec_u8ZZ_clone_ptr(arg: bigint): bigint {
17110 if(!isWasmInitialized) {
17111 throw new Error("initializeWasm() must be awaited first!");
17113 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_clone_ptr(arg);
17114 return nativeResponseValue;
17116 // struct LDKC2Tuple_OutPointCVec_u8ZZ C2Tuple_OutPointCVec_u8ZZ_clone(const struct LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR orig);
17118 export function C2Tuple_OutPointCVec_u8ZZ_clone(orig: bigint): bigint {
17119 if(!isWasmInitialized) {
17120 throw new Error("initializeWasm() must be awaited first!");
17122 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_clone(orig);
17123 return nativeResponseValue;
17125 // struct LDKC2Tuple_OutPointCVec_u8ZZ C2Tuple_OutPointCVec_u8ZZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
17127 export function C2Tuple_OutPointCVec_u8ZZ_new(a: bigint, b: number): bigint {
17128 if(!isWasmInitialized) {
17129 throw new Error("initializeWasm() must be awaited first!");
17131 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_new(a, b);
17132 return nativeResponseValue;
17134 // void C2Tuple_OutPointCVec_u8ZZ_free(struct LDKC2Tuple_OutPointCVec_u8ZZ _res);
17136 export function C2Tuple_OutPointCVec_u8ZZ_free(_res: bigint): void {
17137 if(!isWasmInitialized) {
17138 throw new Error("initializeWasm() must be awaited first!");
17140 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_free(_res);
17141 // debug statements here
17143 // uint64_t C2Tuple_u32CVec_u8ZZ_clone_ptr(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR arg);
17145 export function C2Tuple_u32CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
17146 if(!isWasmInitialized) {
17147 throw new Error("initializeWasm() must be awaited first!");
17149 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_clone_ptr(arg);
17150 return nativeResponseValue;
17152 // struct LDKC2Tuple_u32CVec_u8ZZ C2Tuple_u32CVec_u8ZZ_clone(const struct LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR orig);
17154 export function C2Tuple_u32CVec_u8ZZ_clone(orig: bigint): bigint {
17155 if(!isWasmInitialized) {
17156 throw new Error("initializeWasm() must be awaited first!");
17158 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_clone(orig);
17159 return nativeResponseValue;
17161 // struct LDKC2Tuple_u32CVec_u8ZZ C2Tuple_u32CVec_u8ZZ_new(uint32_t a, struct LDKCVec_u8Z b);
17163 export function C2Tuple_u32CVec_u8ZZ_new(a: number, b: number): bigint {
17164 if(!isWasmInitialized) {
17165 throw new Error("initializeWasm() must be awaited first!");
17167 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_new(a, b);
17168 return nativeResponseValue;
17170 // void C2Tuple_u32CVec_u8ZZ_free(struct LDKC2Tuple_u32CVec_u8ZZ _res);
17172 export function C2Tuple_u32CVec_u8ZZ_free(_res: bigint): void {
17173 if(!isWasmInitialized) {
17174 throw new Error("initializeWasm() must be awaited first!");
17176 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_free(_res);
17177 // debug statements here
17179 // void CVec_C2Tuple_u32CVec_u8ZZZ_free(struct LDKCVec_C2Tuple_u32CVec_u8ZZZ _res);
17181 export function CVec_C2Tuple_u32CVec_u8ZZZ_free(_res: number): void {
17182 if(!isWasmInitialized) {
17183 throw new Error("initializeWasm() must be awaited first!");
17185 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32CVec_u8ZZZ_free(_res);
17186 // debug statements here
17188 // uint64_t C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR arg);
17190 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(arg: bigint): bigint {
17191 if(!isWasmInitialized) {
17192 throw new Error("initializeWasm() must be awaited first!");
17194 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(arg);
17195 return nativeResponseValue;
17197 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR orig);
17199 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(orig: bigint): bigint {
17200 if(!isWasmInitialized) {
17201 throw new Error("initializeWasm() must be awaited first!");
17203 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(orig);
17204 return nativeResponseValue;
17206 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32CVec_u8ZZZ b);
17208 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(a: number, b: number): bigint {
17209 if(!isWasmInitialized) {
17210 throw new Error("initializeWasm() must be awaited first!");
17212 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(a, b);
17213 return nativeResponseValue;
17215 // void C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ _res);
17217 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(_res: bigint): void {
17218 if(!isWasmInitialized) {
17219 throw new Error("initializeWasm() must be awaited first!");
17221 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(_res);
17222 // debug statements here
17224 // void CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ _res);
17226 export function CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(_res: number): void {
17227 if(!isWasmInitialized) {
17228 throw new Error("initializeWasm() must be awaited first!");
17230 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(_res);
17231 // debug statements here
17233 // void CVec_CommitmentTransactionZ_free(struct LDKCVec_CommitmentTransactionZ _res);
17235 export function CVec_CommitmentTransactionZ_free(_res: number): void {
17236 if(!isWasmInitialized) {
17237 throw new Error("initializeWasm() must be awaited first!");
17239 const nativeResponseValue = wasm.TS_CVec_CommitmentTransactionZ_free(_res);
17240 // debug statements here
17242 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
17244 export function CVec_TransactionZ_free(_res: number): void {
17245 if(!isWasmInitialized) {
17246 throw new Error("initializeWasm() must be awaited first!");
17248 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
17249 // debug statements here
17251 // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
17253 export function C2Tuple_u32TxOutZ_clone_ptr(arg: bigint): bigint {
17254 if(!isWasmInitialized) {
17255 throw new Error("initializeWasm() must be awaited first!");
17257 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
17258 return nativeResponseValue;
17260 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
17262 export function C2Tuple_u32TxOutZ_clone(orig: bigint): bigint {
17263 if(!isWasmInitialized) {
17264 throw new Error("initializeWasm() must be awaited first!");
17266 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
17267 return nativeResponseValue;
17269 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
17271 export function C2Tuple_u32TxOutZ_new(a: number, b: bigint): bigint {
17272 if(!isWasmInitialized) {
17273 throw new Error("initializeWasm() must be awaited first!");
17275 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
17276 return nativeResponseValue;
17278 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
17280 export function C2Tuple_u32TxOutZ_free(_res: bigint): void {
17281 if(!isWasmInitialized) {
17282 throw new Error("initializeWasm() must be awaited first!");
17284 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
17285 // debug statements here
17287 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
17289 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
17290 if(!isWasmInitialized) {
17291 throw new Error("initializeWasm() must be awaited first!");
17293 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
17294 // debug statements here
17296 // uint64_t C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
17298 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: bigint): bigint {
17299 if(!isWasmInitialized) {
17300 throw new Error("initializeWasm() must be awaited first!");
17302 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
17303 return nativeResponseValue;
17305 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
17307 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(orig: bigint): bigint {
17308 if(!isWasmInitialized) {
17309 throw new Error("initializeWasm() must be awaited first!");
17311 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(orig);
17312 return nativeResponseValue;
17314 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
17316 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): bigint {
17317 if(!isWasmInitialized) {
17318 throw new Error("initializeWasm() must be awaited first!");
17320 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(a, b);
17321 return nativeResponseValue;
17323 // void C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ _res);
17325 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(_res: bigint): void {
17326 if(!isWasmInitialized) {
17327 throw new Error("initializeWasm() must be awaited first!");
17329 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(_res);
17330 // debug statements here
17332 // void CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ _res);
17334 export function CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
17335 if(!isWasmInitialized) {
17336 throw new Error("initializeWasm() must be awaited first!");
17338 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(_res);
17339 // debug statements here
17341 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
17343 export function CVec_BalanceZ_free(_res: number): void {
17344 if(!isWasmInitialized) {
17345 throw new Error("initializeWasm() must be awaited first!");
17347 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
17348 // debug statements here
17350 // uint64_t C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR arg);
17352 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(arg: bigint): bigint {
17353 if(!isWasmInitialized) {
17354 throw new Error("initializeWasm() must be awaited first!");
17356 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(arg);
17357 return nativeResponseValue;
17359 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR orig);
17361 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(orig: bigint): bigint {
17362 if(!isWasmInitialized) {
17363 throw new Error("initializeWasm() must be awaited first!");
17365 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(orig);
17366 return nativeResponseValue;
17368 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
17370 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(a: number, b: bigint): bigint {
17371 if(!isWasmInitialized) {
17372 throw new Error("initializeWasm() must be awaited first!");
17374 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(a, b);
17375 return nativeResponseValue;
17377 // void C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ _res);
17379 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(_res: bigint): void {
17380 if(!isWasmInitialized) {
17381 throw new Error("initializeWasm() must be awaited first!");
17383 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(_res);
17384 // debug statements here
17386 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ o);
17388 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(o: bigint): bigint {
17389 if(!isWasmInitialized) {
17390 throw new Error("initializeWasm() must be awaited first!");
17392 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(o);
17393 return nativeResponseValue;
17395 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
17397 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(e: bigint): bigint {
17398 if(!isWasmInitialized) {
17399 throw new Error("initializeWasm() must be awaited first!");
17401 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(e);
17402 return nativeResponseValue;
17404 // bool CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
17406 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(o: bigint): boolean {
17407 if(!isWasmInitialized) {
17408 throw new Error("initializeWasm() must be awaited first!");
17410 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(o);
17411 return nativeResponseValue;
17413 // void CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ _res);
17415 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(_res: bigint): void {
17416 if(!isWasmInitialized) {
17417 throw new Error("initializeWasm() must be awaited first!");
17419 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(_res);
17420 // debug statements here
17422 // uint64_t CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
17424 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17425 if(!isWasmInitialized) {
17426 throw new Error("initializeWasm() must be awaited first!");
17428 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(arg);
17429 return nativeResponseValue;
17431 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
17433 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(orig: bigint): bigint {
17434 if(!isWasmInitialized) {
17435 throw new Error("initializeWasm() must be awaited first!");
17437 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(orig);
17438 return nativeResponseValue;
17440 // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
17442 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: bigint): bigint {
17443 if(!isWasmInitialized) {
17444 throw new Error("initializeWasm() must be awaited first!");
17446 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
17447 return nativeResponseValue;
17449 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
17451 export function C2Tuple_PublicKeyTypeZ_clone(orig: bigint): bigint {
17452 if(!isWasmInitialized) {
17453 throw new Error("initializeWasm() must be awaited first!");
17455 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
17456 return nativeResponseValue;
17458 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
17460 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: bigint): bigint {
17461 if(!isWasmInitialized) {
17462 throw new Error("initializeWasm() must be awaited first!");
17464 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
17465 return nativeResponseValue;
17467 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
17469 export function C2Tuple_PublicKeyTypeZ_free(_res: bigint): void {
17470 if(!isWasmInitialized) {
17471 throw new Error("initializeWasm() must be awaited first!");
17473 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
17474 // debug statements here
17476 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
17478 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
17479 if(!isWasmInitialized) {
17480 throw new Error("initializeWasm() must be awaited first!");
17482 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
17483 // debug statements here
17485 // struct LDKCOption_OnionMessageContentsZ COption_OnionMessageContentsZ_some(struct LDKOnionMessageContents o);
17487 export function COption_OnionMessageContentsZ_some(o: bigint): bigint {
17488 if(!isWasmInitialized) {
17489 throw new Error("initializeWasm() must be awaited first!");
17491 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_some(o);
17492 return nativeResponseValue;
17494 // struct LDKCOption_OnionMessageContentsZ COption_OnionMessageContentsZ_none(void);
17496 export function COption_OnionMessageContentsZ_none(): bigint {
17497 if(!isWasmInitialized) {
17498 throw new Error("initializeWasm() must be awaited first!");
17500 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_none();
17501 return nativeResponseValue;
17503 // void COption_OnionMessageContentsZ_free(struct LDKCOption_OnionMessageContentsZ _res);
17505 export function COption_OnionMessageContentsZ_free(_res: bigint): void {
17506 if(!isWasmInitialized) {
17507 throw new Error("initializeWasm() must be awaited first!");
17509 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_free(_res);
17510 // debug statements here
17512 // uint64_t COption_OnionMessageContentsZ_clone_ptr(LDKCOption_OnionMessageContentsZ *NONNULL_PTR arg);
17514 export function COption_OnionMessageContentsZ_clone_ptr(arg: bigint): bigint {
17515 if(!isWasmInitialized) {
17516 throw new Error("initializeWasm() must be awaited first!");
17518 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_clone_ptr(arg);
17519 return nativeResponseValue;
17521 // struct LDKCOption_OnionMessageContentsZ COption_OnionMessageContentsZ_clone(const struct LDKCOption_OnionMessageContentsZ *NONNULL_PTR orig);
17523 export function COption_OnionMessageContentsZ_clone(orig: bigint): bigint {
17524 if(!isWasmInitialized) {
17525 throw new Error("initializeWasm() must be awaited first!");
17527 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_clone(orig);
17528 return nativeResponseValue;
17530 // struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CResult_COption_OnionMessageContentsZDecodeErrorZ_ok(struct LDKCOption_OnionMessageContentsZ o);
17532 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_ok(o: bigint): bigint {
17533 if(!isWasmInitialized) {
17534 throw new Error("initializeWasm() must be awaited first!");
17536 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_ok(o);
17537 return nativeResponseValue;
17539 // struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CResult_COption_OnionMessageContentsZDecodeErrorZ_err(struct LDKDecodeError e);
17541 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_err(e: bigint): bigint {
17542 if(!isWasmInitialized) {
17543 throw new Error("initializeWasm() must be awaited first!");
17545 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_err(e);
17546 return nativeResponseValue;
17548 // bool CResult_COption_OnionMessageContentsZDecodeErrorZ_is_ok(const struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR o);
17550 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_is_ok(o: bigint): boolean {
17551 if(!isWasmInitialized) {
17552 throw new Error("initializeWasm() must be awaited first!");
17554 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_is_ok(o);
17555 return nativeResponseValue;
17557 // void CResult_COption_OnionMessageContentsZDecodeErrorZ_free(struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ _res);
17559 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_free(_res: bigint): void {
17560 if(!isWasmInitialized) {
17561 throw new Error("initializeWasm() must be awaited first!");
17563 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_free(_res);
17564 // debug statements here
17566 // uint64_t CResult_COption_OnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg);
17568 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17569 if(!isWasmInitialized) {
17570 throw new Error("initializeWasm() must be awaited first!");
17572 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_clone_ptr(arg);
17573 return nativeResponseValue;
17575 // struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CResult_COption_OnionMessageContentsZDecodeErrorZ_clone(const struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR orig);
17577 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_clone(orig: bigint): bigint {
17578 if(!isWasmInitialized) {
17579 throw new Error("initializeWasm() must be awaited first!");
17581 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_clone(orig);
17582 return nativeResponseValue;
17584 // uint64_t C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone_ptr(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR arg);
17586 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone_ptr(arg: bigint): bigint {
17587 if(!isWasmInitialized) {
17588 throw new Error("initializeWasm() must be awaited first!");
17590 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone_ptr(arg);
17591 return nativeResponseValue;
17593 // struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone(const struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR orig);
17595 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone(orig: bigint): bigint {
17596 if(!isWasmInitialized) {
17597 throw new Error("initializeWasm() must be awaited first!");
17599 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone(orig);
17600 return nativeResponseValue;
17602 // struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ C3Tuple_OnionMessageContentsDestinationBlindedPathZ_new(struct LDKOnionMessageContents a, struct LDKDestination b, struct LDKBlindedPath c);
17604 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_new(a: bigint, b: bigint, c: bigint): bigint {
17605 if(!isWasmInitialized) {
17606 throw new Error("initializeWasm() must be awaited first!");
17608 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_new(a, b, c);
17609 return nativeResponseValue;
17611 // void C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ _res);
17613 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(_res: bigint): void {
17614 if(!isWasmInitialized) {
17615 throw new Error("initializeWasm() must be awaited first!");
17617 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(_res);
17618 // debug statements here
17620 // void CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(struct LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ _res);
17622 export function CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(_res: number): void {
17623 if(!isWasmInitialized) {
17624 throw new Error("initializeWasm() must be awaited first!");
17626 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(_res);
17627 // debug statements here
17629 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
17631 export function COption_TypeZ_some(o: bigint): bigint {
17632 if(!isWasmInitialized) {
17633 throw new Error("initializeWasm() must be awaited first!");
17635 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
17636 return nativeResponseValue;
17638 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
17640 export function COption_TypeZ_none(): bigint {
17641 if(!isWasmInitialized) {
17642 throw new Error("initializeWasm() must be awaited first!");
17644 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
17645 return nativeResponseValue;
17647 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
17649 export function COption_TypeZ_free(_res: bigint): void {
17650 if(!isWasmInitialized) {
17651 throw new Error("initializeWasm() must be awaited first!");
17653 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
17654 // debug statements here
17656 // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
17658 export function COption_TypeZ_clone_ptr(arg: bigint): bigint {
17659 if(!isWasmInitialized) {
17660 throw new Error("initializeWasm() must be awaited first!");
17662 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
17663 return nativeResponseValue;
17665 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
17667 export function COption_TypeZ_clone(orig: bigint): bigint {
17668 if(!isWasmInitialized) {
17669 throw new Error("initializeWasm() must be awaited first!");
17671 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
17672 return nativeResponseValue;
17674 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
17676 export function CResult_COption_TypeZDecodeErrorZ_ok(o: bigint): bigint {
17677 if(!isWasmInitialized) {
17678 throw new Error("initializeWasm() must be awaited first!");
17680 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
17681 return nativeResponseValue;
17683 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
17685 export function CResult_COption_TypeZDecodeErrorZ_err(e: bigint): bigint {
17686 if(!isWasmInitialized) {
17687 throw new Error("initializeWasm() must be awaited first!");
17689 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
17690 return nativeResponseValue;
17692 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
17694 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: bigint): boolean {
17695 if(!isWasmInitialized) {
17696 throw new Error("initializeWasm() must be awaited first!");
17698 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
17699 return nativeResponseValue;
17701 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
17703 export function CResult_COption_TypeZDecodeErrorZ_free(_res: bigint): void {
17704 if(!isWasmInitialized) {
17705 throw new Error("initializeWasm() must be awaited first!");
17707 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
17708 // debug statements here
17710 // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
17712 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17713 if(!isWasmInitialized) {
17714 throw new Error("initializeWasm() must be awaited first!");
17716 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
17717 return nativeResponseValue;
17719 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
17721 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: bigint): bigint {
17722 if(!isWasmInitialized) {
17723 throw new Error("initializeWasm() must be awaited first!");
17725 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
17726 return nativeResponseValue;
17728 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_some(struct LDKSocketAddress o);
17730 export function COption_SocketAddressZ_some(o: bigint): bigint {
17731 if(!isWasmInitialized) {
17732 throw new Error("initializeWasm() must be awaited first!");
17734 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_some(o);
17735 return nativeResponseValue;
17737 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_none(void);
17739 export function COption_SocketAddressZ_none(): bigint {
17740 if(!isWasmInitialized) {
17741 throw new Error("initializeWasm() must be awaited first!");
17743 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_none();
17744 return nativeResponseValue;
17746 // void COption_SocketAddressZ_free(struct LDKCOption_SocketAddressZ _res);
17748 export function COption_SocketAddressZ_free(_res: bigint): void {
17749 if(!isWasmInitialized) {
17750 throw new Error("initializeWasm() must be awaited first!");
17752 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_free(_res);
17753 // debug statements here
17755 // uint64_t COption_SocketAddressZ_clone_ptr(LDKCOption_SocketAddressZ *NONNULL_PTR arg);
17757 export function COption_SocketAddressZ_clone_ptr(arg: bigint): bigint {
17758 if(!isWasmInitialized) {
17759 throw new Error("initializeWasm() must be awaited first!");
17761 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_clone_ptr(arg);
17762 return nativeResponseValue;
17764 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_clone(const struct LDKCOption_SocketAddressZ *NONNULL_PTR orig);
17766 export function COption_SocketAddressZ_clone(orig: bigint): bigint {
17767 if(!isWasmInitialized) {
17768 throw new Error("initializeWasm() must be awaited first!");
17770 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_clone(orig);
17771 return nativeResponseValue;
17773 // uint64_t C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR arg);
17775 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(arg: bigint): bigint {
17776 if(!isWasmInitialized) {
17777 throw new Error("initializeWasm() must be awaited first!");
17779 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(arg);
17780 return nativeResponseValue;
17782 // struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(const struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR orig);
17784 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(orig: bigint): bigint {
17785 if(!isWasmInitialized) {
17786 throw new Error("initializeWasm() must be awaited first!");
17788 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(orig);
17789 return nativeResponseValue;
17791 // struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ C2Tuple_PublicKeyCOption_SocketAddressZZ_new(struct LDKPublicKey a, struct LDKCOption_SocketAddressZ b);
17793 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_new(a: number, b: bigint): bigint {
17794 if(!isWasmInitialized) {
17795 throw new Error("initializeWasm() must be awaited first!");
17797 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_new(a, b);
17798 return nativeResponseValue;
17800 // void C2Tuple_PublicKeyCOption_SocketAddressZZ_free(struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ _res);
17802 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_free(_res: bigint): void {
17803 if(!isWasmInitialized) {
17804 throw new Error("initializeWasm() must be awaited first!");
17806 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_free(_res);
17807 // debug statements here
17809 // void CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(struct LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ _res);
17811 export function CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(_res: number): void {
17812 if(!isWasmInitialized) {
17813 throw new Error("initializeWasm() must be awaited first!");
17815 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(_res);
17816 // debug statements here
17818 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
17820 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): bigint {
17821 if(!isWasmInitialized) {
17822 throw new Error("initializeWasm() must be awaited first!");
17824 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
17825 return nativeResponseValue;
17827 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
17829 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: bigint): bigint {
17830 if(!isWasmInitialized) {
17831 throw new Error("initializeWasm() must be awaited first!");
17833 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
17834 return nativeResponseValue;
17836 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
17838 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: bigint): boolean {
17839 if(!isWasmInitialized) {
17840 throw new Error("initializeWasm() must be awaited first!");
17842 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
17843 return nativeResponseValue;
17845 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
17847 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: bigint): void {
17848 if(!isWasmInitialized) {
17849 throw new Error("initializeWasm() must be awaited first!");
17851 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
17852 // debug statements here
17854 // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
17856 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
17857 if(!isWasmInitialized) {
17858 throw new Error("initializeWasm() must be awaited first!");
17860 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
17861 return nativeResponseValue;
17863 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
17865 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: bigint): bigint {
17866 if(!isWasmInitialized) {
17867 throw new Error("initializeWasm() must be awaited first!");
17869 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
17870 return nativeResponseValue;
17872 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
17874 export function CResult_NonePeerHandleErrorZ_ok(): bigint {
17875 if(!isWasmInitialized) {
17876 throw new Error("initializeWasm() must be awaited first!");
17878 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
17879 return nativeResponseValue;
17881 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
17883 export function CResult_NonePeerHandleErrorZ_err(e: bigint): bigint {
17884 if(!isWasmInitialized) {
17885 throw new Error("initializeWasm() must be awaited first!");
17887 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
17888 return nativeResponseValue;
17890 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
17892 export function CResult_NonePeerHandleErrorZ_is_ok(o: bigint): boolean {
17893 if(!isWasmInitialized) {
17894 throw new Error("initializeWasm() must be awaited first!");
17896 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
17897 return nativeResponseValue;
17899 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
17901 export function CResult_NonePeerHandleErrorZ_free(_res: bigint): void {
17902 if(!isWasmInitialized) {
17903 throw new Error("initializeWasm() must be awaited first!");
17905 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
17906 // debug statements here
17908 // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
17910 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
17911 if(!isWasmInitialized) {
17912 throw new Error("initializeWasm() must be awaited first!");
17914 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
17915 return nativeResponseValue;
17917 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
17919 export function CResult_NonePeerHandleErrorZ_clone(orig: bigint): bigint {
17920 if(!isWasmInitialized) {
17921 throw new Error("initializeWasm() must be awaited first!");
17923 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
17924 return nativeResponseValue;
17926 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
17928 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): bigint {
17929 if(!isWasmInitialized) {
17930 throw new Error("initializeWasm() must be awaited first!");
17932 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
17933 return nativeResponseValue;
17935 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
17937 export function CResult_boolPeerHandleErrorZ_err(e: bigint): bigint {
17938 if(!isWasmInitialized) {
17939 throw new Error("initializeWasm() must be awaited first!");
17941 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
17942 return nativeResponseValue;
17944 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
17946 export function CResult_boolPeerHandleErrorZ_is_ok(o: bigint): boolean {
17947 if(!isWasmInitialized) {
17948 throw new Error("initializeWasm() must be awaited first!");
17950 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
17951 return nativeResponseValue;
17953 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
17955 export function CResult_boolPeerHandleErrorZ_free(_res: bigint): void {
17956 if(!isWasmInitialized) {
17957 throw new Error("initializeWasm() must be awaited first!");
17959 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
17960 // debug statements here
17962 // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
17964 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
17965 if(!isWasmInitialized) {
17966 throw new Error("initializeWasm() must be awaited first!");
17968 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
17969 return nativeResponseValue;
17971 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
17973 export function CResult_boolPeerHandleErrorZ_clone(orig: bigint): bigint {
17974 if(!isWasmInitialized) {
17975 throw new Error("initializeWasm() must be awaited first!");
17977 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
17978 return nativeResponseValue;
17980 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_ok(uint32_t o);
17982 export function CResult_u32GraphSyncErrorZ_ok(o: number): bigint {
17983 if(!isWasmInitialized) {
17984 throw new Error("initializeWasm() must be awaited first!");
17986 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_ok(o);
17987 return nativeResponseValue;
17989 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_err(struct LDKGraphSyncError e);
17991 export function CResult_u32GraphSyncErrorZ_err(e: bigint): bigint {
17992 if(!isWasmInitialized) {
17993 throw new Error("initializeWasm() must be awaited first!");
17995 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_err(e);
17996 return nativeResponseValue;
17998 // bool CResult_u32GraphSyncErrorZ_is_ok(const struct LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR o);
18000 export function CResult_u32GraphSyncErrorZ_is_ok(o: bigint): boolean {
18001 if(!isWasmInitialized) {
18002 throw new Error("initializeWasm() must be awaited first!");
18004 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_is_ok(o);
18005 return nativeResponseValue;
18007 // void CResult_u32GraphSyncErrorZ_free(struct LDKCResult_u32GraphSyncErrorZ _res);
18009 export function CResult_u32GraphSyncErrorZ_free(_res: bigint): void {
18010 if(!isWasmInitialized) {
18011 throw new Error("initializeWasm() must be awaited first!");
18013 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_free(_res);
18014 // debug statements here
18016 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_ok(struct LDKCVec_u8Z o);
18018 export function CResult_CVec_u8ZIOErrorZ_ok(o: number): bigint {
18019 if(!isWasmInitialized) {
18020 throw new Error("initializeWasm() must be awaited first!");
18022 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_ok(o);
18023 return nativeResponseValue;
18025 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_err(enum LDKIOError e);
18027 export function CResult_CVec_u8ZIOErrorZ_err(e: IOError): bigint {
18028 if(!isWasmInitialized) {
18029 throw new Error("initializeWasm() must be awaited first!");
18031 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_err(e);
18032 return nativeResponseValue;
18034 // bool CResult_CVec_u8ZIOErrorZ_is_ok(const struct LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR o);
18036 export function CResult_CVec_u8ZIOErrorZ_is_ok(o: bigint): boolean {
18037 if(!isWasmInitialized) {
18038 throw new Error("initializeWasm() must be awaited first!");
18040 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_is_ok(o);
18041 return nativeResponseValue;
18043 // void CResult_CVec_u8ZIOErrorZ_free(struct LDKCResult_CVec_u8ZIOErrorZ _res);
18045 export function CResult_CVec_u8ZIOErrorZ_free(_res: bigint): void {
18046 if(!isWasmInitialized) {
18047 throw new Error("initializeWasm() must be awaited first!");
18049 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_free(_res);
18050 // debug statements here
18052 // uint64_t CResult_CVec_u8ZIOErrorZ_clone_ptr(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR arg);
18054 export function CResult_CVec_u8ZIOErrorZ_clone_ptr(arg: bigint): bigint {
18055 if(!isWasmInitialized) {
18056 throw new Error("initializeWasm() must be awaited first!");
18058 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_clone_ptr(arg);
18059 return nativeResponseValue;
18061 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_clone(const struct LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR orig);
18063 export function CResult_CVec_u8ZIOErrorZ_clone(orig: bigint): bigint {
18064 if(!isWasmInitialized) {
18065 throw new Error("initializeWasm() must be awaited first!");
18067 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_clone(orig);
18068 return nativeResponseValue;
18070 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_ok(void);
18072 export function CResult_NoneIOErrorZ_ok(): bigint {
18073 if(!isWasmInitialized) {
18074 throw new Error("initializeWasm() must be awaited first!");
18076 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_ok();
18077 return nativeResponseValue;
18079 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_err(enum LDKIOError e);
18081 export function CResult_NoneIOErrorZ_err(e: IOError): bigint {
18082 if(!isWasmInitialized) {
18083 throw new Error("initializeWasm() must be awaited first!");
18085 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_err(e);
18086 return nativeResponseValue;
18088 // bool CResult_NoneIOErrorZ_is_ok(const struct LDKCResult_NoneIOErrorZ *NONNULL_PTR o);
18090 export function CResult_NoneIOErrorZ_is_ok(o: bigint): boolean {
18091 if(!isWasmInitialized) {
18092 throw new Error("initializeWasm() must be awaited first!");
18094 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_is_ok(o);
18095 return nativeResponseValue;
18097 // void CResult_NoneIOErrorZ_free(struct LDKCResult_NoneIOErrorZ _res);
18099 export function CResult_NoneIOErrorZ_free(_res: bigint): void {
18100 if(!isWasmInitialized) {
18101 throw new Error("initializeWasm() must be awaited first!");
18103 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_free(_res);
18104 // debug statements here
18106 // uint64_t CResult_NoneIOErrorZ_clone_ptr(LDKCResult_NoneIOErrorZ *NONNULL_PTR arg);
18108 export function CResult_NoneIOErrorZ_clone_ptr(arg: bigint): bigint {
18109 if(!isWasmInitialized) {
18110 throw new Error("initializeWasm() must be awaited first!");
18112 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_clone_ptr(arg);
18113 return nativeResponseValue;
18115 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_clone(const struct LDKCResult_NoneIOErrorZ *NONNULL_PTR orig);
18117 export function CResult_NoneIOErrorZ_clone(orig: bigint): bigint {
18118 if(!isWasmInitialized) {
18119 throw new Error("initializeWasm() must be awaited first!");
18121 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_clone(orig);
18122 return nativeResponseValue;
18124 // void CVec_StrZ_free(struct LDKCVec_StrZ _res);
18126 export function CVec_StrZ_free(_res: number): void {
18127 if(!isWasmInitialized) {
18128 throw new Error("initializeWasm() must be awaited first!");
18130 const nativeResponseValue = wasm.TS_CVec_StrZ_free(_res);
18131 // debug statements here
18133 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_ok(struct LDKCVec_StrZ o);
18135 export function CResult_CVec_StrZIOErrorZ_ok(o: number): bigint {
18136 if(!isWasmInitialized) {
18137 throw new Error("initializeWasm() must be awaited first!");
18139 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_ok(o);
18140 return nativeResponseValue;
18142 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_err(enum LDKIOError e);
18144 export function CResult_CVec_StrZIOErrorZ_err(e: IOError): bigint {
18145 if(!isWasmInitialized) {
18146 throw new Error("initializeWasm() must be awaited first!");
18148 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_err(e);
18149 return nativeResponseValue;
18151 // bool CResult_CVec_StrZIOErrorZ_is_ok(const struct LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR o);
18153 export function CResult_CVec_StrZIOErrorZ_is_ok(o: bigint): boolean {
18154 if(!isWasmInitialized) {
18155 throw new Error("initializeWasm() must be awaited first!");
18157 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_is_ok(o);
18158 return nativeResponseValue;
18160 // void CResult_CVec_StrZIOErrorZ_free(struct LDKCResult_CVec_StrZIOErrorZ _res);
18162 export function CResult_CVec_StrZIOErrorZ_free(_res: bigint): void {
18163 if(!isWasmInitialized) {
18164 throw new Error("initializeWasm() must be awaited first!");
18166 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_free(_res);
18167 // debug statements here
18169 // uint64_t CResult_CVec_StrZIOErrorZ_clone_ptr(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR arg);
18171 export function CResult_CVec_StrZIOErrorZ_clone_ptr(arg: bigint): bigint {
18172 if(!isWasmInitialized) {
18173 throw new Error("initializeWasm() must be awaited first!");
18175 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_clone_ptr(arg);
18176 return nativeResponseValue;
18178 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_clone(const struct LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR orig);
18180 export function CResult_CVec_StrZIOErrorZ_clone(orig: bigint): bigint {
18181 if(!isWasmInitialized) {
18182 throw new Error("initializeWasm() must be awaited first!");
18184 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_clone(orig);
18185 return nativeResponseValue;
18187 // void CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ _res);
18189 export function CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(_res: number): void {
18190 if(!isWasmInitialized) {
18191 throw new Error("initializeWasm() must be awaited first!");
18193 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(_res);
18194 // debug statements here
18196 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ o);
18198 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(o: number): bigint {
18199 if(!isWasmInitialized) {
18200 throw new Error("initializeWasm() must be awaited first!");
18202 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(o);
18203 return nativeResponseValue;
18205 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(enum LDKIOError e);
18207 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(e: IOError): bigint {
18208 if(!isWasmInitialized) {
18209 throw new Error("initializeWasm() must be awaited first!");
18211 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(e);
18212 return nativeResponseValue;
18214 // bool CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR o);
18216 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(o: bigint): boolean {
18217 if(!isWasmInitialized) {
18218 throw new Error("initializeWasm() must be awaited first!");
18220 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(o);
18221 return nativeResponseValue;
18223 // void CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ _res);
18225 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(_res: bigint): void {
18226 if(!isWasmInitialized) {
18227 throw new Error("initializeWasm() must be awaited first!");
18229 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(_res);
18230 // debug statements here
18232 // uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR arg);
18234 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(arg: bigint): bigint {
18235 if(!isWasmInitialized) {
18236 throw new Error("initializeWasm() must be awaited first!");
18238 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(arg);
18239 return nativeResponseValue;
18241 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR orig);
18243 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(orig: bigint): bigint {
18244 if(!isWasmInitialized) {
18245 throw new Error("initializeWasm() must be awaited first!");
18247 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(orig);
18248 return nativeResponseValue;
18250 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ o);
18252 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(o: bigint): bigint {
18253 if(!isWasmInitialized) {
18254 throw new Error("initializeWasm() must be awaited first!");
18256 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(o);
18257 return nativeResponseValue;
18259 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(enum LDKIOError e);
18261 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(e: IOError): bigint {
18262 if(!isWasmInitialized) {
18263 throw new Error("initializeWasm() must be awaited first!");
18265 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(e);
18266 return nativeResponseValue;
18268 // bool CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR o);
18270 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(o: bigint): boolean {
18271 if(!isWasmInitialized) {
18272 throw new Error("initializeWasm() must be awaited first!");
18274 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(o);
18275 return nativeResponseValue;
18277 // void CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ _res);
18279 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(_res: bigint): void {
18280 if(!isWasmInitialized) {
18281 throw new Error("initializeWasm() must be awaited first!");
18283 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(_res);
18284 // debug statements here
18286 // uint64_t CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR arg);
18288 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(arg: bigint): bigint {
18289 if(!isWasmInitialized) {
18290 throw new Error("initializeWasm() must be awaited first!");
18292 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(arg);
18293 return nativeResponseValue;
18295 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR orig);
18297 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(orig: bigint): bigint {
18298 if(!isWasmInitialized) {
18299 throw new Error("initializeWasm() must be awaited first!");
18301 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(orig);
18302 return nativeResponseValue;
18304 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_some(struct LDKSecretKey o);
18306 export function COption_SecretKeyZ_some(o: number): bigint {
18307 if(!isWasmInitialized) {
18308 throw new Error("initializeWasm() must be awaited first!");
18310 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_some(o);
18311 return nativeResponseValue;
18313 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_none(void);
18315 export function COption_SecretKeyZ_none(): bigint {
18316 if(!isWasmInitialized) {
18317 throw new Error("initializeWasm() must be awaited first!");
18319 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_none();
18320 return nativeResponseValue;
18322 // void COption_SecretKeyZ_free(struct LDKCOption_SecretKeyZ _res);
18324 export function COption_SecretKeyZ_free(_res: bigint): void {
18325 if(!isWasmInitialized) {
18326 throw new Error("initializeWasm() must be awaited first!");
18328 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_free(_res);
18329 // debug statements here
18331 // uint64_t COption_SecretKeyZ_clone_ptr(LDKCOption_SecretKeyZ *NONNULL_PTR arg);
18333 export function COption_SecretKeyZ_clone_ptr(arg: bigint): bigint {
18334 if(!isWasmInitialized) {
18335 throw new Error("initializeWasm() must be awaited first!");
18337 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_clone_ptr(arg);
18338 return nativeResponseValue;
18340 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_clone(const struct LDKCOption_SecretKeyZ *NONNULL_PTR orig);
18342 export function COption_SecretKeyZ_clone(orig: bigint): bigint {
18343 if(!isWasmInitialized) {
18344 throw new Error("initializeWasm() must be awaited first!");
18346 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_clone(orig);
18347 return nativeResponseValue;
18349 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_ok(struct LDKVerifiedInvoiceRequest o);
18351 export function CResult_VerifiedInvoiceRequestNoneZ_ok(o: bigint): bigint {
18352 if(!isWasmInitialized) {
18353 throw new Error("initializeWasm() must be awaited first!");
18355 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_ok(o);
18356 return nativeResponseValue;
18358 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_err(void);
18360 export function CResult_VerifiedInvoiceRequestNoneZ_err(): bigint {
18361 if(!isWasmInitialized) {
18362 throw new Error("initializeWasm() must be awaited first!");
18364 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_err();
18365 return nativeResponseValue;
18367 // bool CResult_VerifiedInvoiceRequestNoneZ_is_ok(const struct LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR o);
18369 export function CResult_VerifiedInvoiceRequestNoneZ_is_ok(o: bigint): boolean {
18370 if(!isWasmInitialized) {
18371 throw new Error("initializeWasm() must be awaited first!");
18373 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_is_ok(o);
18374 return nativeResponseValue;
18376 // void CResult_VerifiedInvoiceRequestNoneZ_free(struct LDKCResult_VerifiedInvoiceRequestNoneZ _res);
18378 export function CResult_VerifiedInvoiceRequestNoneZ_free(_res: bigint): void {
18379 if(!isWasmInitialized) {
18380 throw new Error("initializeWasm() must be awaited first!");
18382 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_free(_res);
18383 // debug statements here
18385 // uint64_t CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR arg);
18387 export function CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(arg: bigint): bigint {
18388 if(!isWasmInitialized) {
18389 throw new Error("initializeWasm() must be awaited first!");
18391 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(arg);
18392 return nativeResponseValue;
18394 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_clone(const struct LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR orig);
18396 export function CResult_VerifiedInvoiceRequestNoneZ_clone(orig: bigint): bigint {
18397 if(!isWasmInitialized) {
18398 throw new Error("initializeWasm() must be awaited first!");
18400 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_clone(orig);
18401 return nativeResponseValue;
18403 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
18405 export function COption_NoneZ_some(): COption_NoneZ {
18406 if(!isWasmInitialized) {
18407 throw new Error("initializeWasm() must be awaited first!");
18409 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
18410 return nativeResponseValue;
18412 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
18414 export function COption_NoneZ_none(): COption_NoneZ {
18415 if(!isWasmInitialized) {
18416 throw new Error("initializeWasm() must be awaited first!");
18418 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
18419 return nativeResponseValue;
18421 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
18423 export function COption_NoneZ_free(_res: COption_NoneZ): void {
18424 if(!isWasmInitialized) {
18425 throw new Error("initializeWasm() must be awaited first!");
18427 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
18428 // debug statements here
18430 // void CVec_WitnessZ_free(struct LDKCVec_WitnessZ _res);
18432 export function CVec_WitnessZ_free(_res: number): void {
18433 if(!isWasmInitialized) {
18434 throw new Error("initializeWasm() must be awaited first!");
18436 const nativeResponseValue = wasm.TS_CVec_WitnessZ_free(_res);
18437 // debug statements here
18439 // struct LDKCOption_i64Z COption_i64Z_some(int64_t o);
18441 export function COption_i64Z_some(o: bigint): bigint {
18442 if(!isWasmInitialized) {
18443 throw new Error("initializeWasm() must be awaited first!");
18445 const nativeResponseValue = wasm.TS_COption_i64Z_some(o);
18446 return nativeResponseValue;
18448 // struct LDKCOption_i64Z COption_i64Z_none(void);
18450 export function COption_i64Z_none(): bigint {
18451 if(!isWasmInitialized) {
18452 throw new Error("initializeWasm() must be awaited first!");
18454 const nativeResponseValue = wasm.TS_COption_i64Z_none();
18455 return nativeResponseValue;
18457 // void COption_i64Z_free(struct LDKCOption_i64Z _res);
18459 export function COption_i64Z_free(_res: bigint): void {
18460 if(!isWasmInitialized) {
18461 throw new Error("initializeWasm() must be awaited first!");
18463 const nativeResponseValue = wasm.TS_COption_i64Z_free(_res);
18464 // debug statements here
18466 // uint64_t COption_i64Z_clone_ptr(LDKCOption_i64Z *NONNULL_PTR arg);
18468 export function COption_i64Z_clone_ptr(arg: bigint): bigint {
18469 if(!isWasmInitialized) {
18470 throw new Error("initializeWasm() must be awaited first!");
18472 const nativeResponseValue = wasm.TS_COption_i64Z_clone_ptr(arg);
18473 return nativeResponseValue;
18475 // struct LDKCOption_i64Z COption_i64Z_clone(const struct LDKCOption_i64Z *NONNULL_PTR orig);
18477 export function COption_i64Z_clone(orig: bigint): bigint {
18478 if(!isWasmInitialized) {
18479 throw new Error("initializeWasm() must be awaited first!");
18481 const nativeResponseValue = wasm.TS_COption_i64Z_clone(orig);
18482 return nativeResponseValue;
18484 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_ok(struct LDKSocketAddress o);
18486 export function CResult_SocketAddressDecodeErrorZ_ok(o: bigint): bigint {
18487 if(!isWasmInitialized) {
18488 throw new Error("initializeWasm() must be awaited first!");
18490 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_ok(o);
18491 return nativeResponseValue;
18493 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_err(struct LDKDecodeError e);
18495 export function CResult_SocketAddressDecodeErrorZ_err(e: bigint): bigint {
18496 if(!isWasmInitialized) {
18497 throw new Error("initializeWasm() must be awaited first!");
18499 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_err(e);
18500 return nativeResponseValue;
18502 // bool CResult_SocketAddressDecodeErrorZ_is_ok(const struct LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR o);
18504 export function CResult_SocketAddressDecodeErrorZ_is_ok(o: bigint): boolean {
18505 if(!isWasmInitialized) {
18506 throw new Error("initializeWasm() must be awaited first!");
18508 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_is_ok(o);
18509 return nativeResponseValue;
18511 // void CResult_SocketAddressDecodeErrorZ_free(struct LDKCResult_SocketAddressDecodeErrorZ _res);
18513 export function CResult_SocketAddressDecodeErrorZ_free(_res: bigint): void {
18514 if(!isWasmInitialized) {
18515 throw new Error("initializeWasm() must be awaited first!");
18517 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_free(_res);
18518 // debug statements here
18520 // uint64_t CResult_SocketAddressDecodeErrorZ_clone_ptr(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR arg);
18522 export function CResult_SocketAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18523 if(!isWasmInitialized) {
18524 throw new Error("initializeWasm() must be awaited first!");
18526 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_clone_ptr(arg);
18527 return nativeResponseValue;
18529 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_clone(const struct LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR orig);
18531 export function CResult_SocketAddressDecodeErrorZ_clone(orig: bigint): bigint {
18532 if(!isWasmInitialized) {
18533 throw new Error("initializeWasm() must be awaited first!");
18535 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_clone(orig);
18536 return nativeResponseValue;
18538 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_ok(struct LDKSocketAddress o);
18540 export function CResult_SocketAddressSocketAddressParseErrorZ_ok(o: bigint): bigint {
18541 if(!isWasmInitialized) {
18542 throw new Error("initializeWasm() must be awaited first!");
18544 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_ok(o);
18545 return nativeResponseValue;
18547 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_err(enum LDKSocketAddressParseError e);
18549 export function CResult_SocketAddressSocketAddressParseErrorZ_err(e: SocketAddressParseError): bigint {
18550 if(!isWasmInitialized) {
18551 throw new Error("initializeWasm() must be awaited first!");
18553 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_err(e);
18554 return nativeResponseValue;
18556 // bool CResult_SocketAddressSocketAddressParseErrorZ_is_ok(const struct LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR o);
18558 export function CResult_SocketAddressSocketAddressParseErrorZ_is_ok(o: bigint): boolean {
18559 if(!isWasmInitialized) {
18560 throw new Error("initializeWasm() must be awaited first!");
18562 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_is_ok(o);
18563 return nativeResponseValue;
18565 // void CResult_SocketAddressSocketAddressParseErrorZ_free(struct LDKCResult_SocketAddressSocketAddressParseErrorZ _res);
18567 export function CResult_SocketAddressSocketAddressParseErrorZ_free(_res: bigint): void {
18568 if(!isWasmInitialized) {
18569 throw new Error("initializeWasm() must be awaited first!");
18571 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_free(_res);
18572 // debug statements here
18574 // uint64_t CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR arg);
18576 export function CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(arg: bigint): bigint {
18577 if(!isWasmInitialized) {
18578 throw new Error("initializeWasm() must be awaited first!");
18580 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(arg);
18581 return nativeResponseValue;
18583 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_clone(const struct LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR orig);
18585 export function CResult_SocketAddressSocketAddressParseErrorZ_clone(orig: bigint): bigint {
18586 if(!isWasmInitialized) {
18587 throw new Error("initializeWasm() must be awaited first!");
18589 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_clone(orig);
18590 return nativeResponseValue;
18592 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
18594 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
18595 if(!isWasmInitialized) {
18596 throw new Error("initializeWasm() must be awaited first!");
18598 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
18599 // debug statements here
18601 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
18603 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
18604 if(!isWasmInitialized) {
18605 throw new Error("initializeWasm() must be awaited first!");
18607 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
18608 // debug statements here
18610 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
18612 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
18613 if(!isWasmInitialized) {
18614 throw new Error("initializeWasm() must be awaited first!");
18616 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
18617 // debug statements here
18619 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
18621 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
18622 if(!isWasmInitialized) {
18623 throw new Error("initializeWasm() must be awaited first!");
18625 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
18626 // debug statements here
18628 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
18630 export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
18631 if(!isWasmInitialized) {
18632 throw new Error("initializeWasm() must be awaited first!");
18634 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
18635 return nativeResponseValue;
18637 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
18639 export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
18640 if(!isWasmInitialized) {
18641 throw new Error("initializeWasm() must be awaited first!");
18643 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
18644 return nativeResponseValue;
18646 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
18648 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
18649 if(!isWasmInitialized) {
18650 throw new Error("initializeWasm() must be awaited first!");
18652 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
18653 return nativeResponseValue;
18655 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
18657 export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
18658 if(!isWasmInitialized) {
18659 throw new Error("initializeWasm() must be awaited first!");
18661 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
18662 // debug statements here
18664 // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
18666 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18667 if(!isWasmInitialized) {
18668 throw new Error("initializeWasm() must be awaited first!");
18670 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
18671 return nativeResponseValue;
18673 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
18675 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
18676 if(!isWasmInitialized) {
18677 throw new Error("initializeWasm() must be awaited first!");
18679 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
18680 return nativeResponseValue;
18682 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_ok(struct LDKAcceptChannelV2 o);
18684 export function CResult_AcceptChannelV2DecodeErrorZ_ok(o: bigint): bigint {
18685 if(!isWasmInitialized) {
18686 throw new Error("initializeWasm() must be awaited first!");
18688 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_ok(o);
18689 return nativeResponseValue;
18691 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_err(struct LDKDecodeError e);
18693 export function CResult_AcceptChannelV2DecodeErrorZ_err(e: bigint): bigint {
18694 if(!isWasmInitialized) {
18695 throw new Error("initializeWasm() must be awaited first!");
18697 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_err(e);
18698 return nativeResponseValue;
18700 // bool CResult_AcceptChannelV2DecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR o);
18702 export function CResult_AcceptChannelV2DecodeErrorZ_is_ok(o: bigint): boolean {
18703 if(!isWasmInitialized) {
18704 throw new Error("initializeWasm() must be awaited first!");
18706 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_is_ok(o);
18707 return nativeResponseValue;
18709 // void CResult_AcceptChannelV2DecodeErrorZ_free(struct LDKCResult_AcceptChannelV2DecodeErrorZ _res);
18711 export function CResult_AcceptChannelV2DecodeErrorZ_free(_res: bigint): void {
18712 if(!isWasmInitialized) {
18713 throw new Error("initializeWasm() must be awaited first!");
18715 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_free(_res);
18716 // debug statements here
18718 // uint64_t CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR arg);
18720 export function CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(arg: bigint): bigint {
18721 if(!isWasmInitialized) {
18722 throw new Error("initializeWasm() must be awaited first!");
18724 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(arg);
18725 return nativeResponseValue;
18727 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_clone(const struct LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR orig);
18729 export function CResult_AcceptChannelV2DecodeErrorZ_clone(orig: bigint): bigint {
18730 if(!isWasmInitialized) {
18731 throw new Error("initializeWasm() must be awaited first!");
18733 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_clone(orig);
18734 return nativeResponseValue;
18736 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_ok(struct LDKTxAddInput o);
18738 export function CResult_TxAddInputDecodeErrorZ_ok(o: bigint): bigint {
18739 if(!isWasmInitialized) {
18740 throw new Error("initializeWasm() must be awaited first!");
18742 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_ok(o);
18743 return nativeResponseValue;
18745 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_err(struct LDKDecodeError e);
18747 export function CResult_TxAddInputDecodeErrorZ_err(e: bigint): bigint {
18748 if(!isWasmInitialized) {
18749 throw new Error("initializeWasm() must be awaited first!");
18751 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_err(e);
18752 return nativeResponseValue;
18754 // bool CResult_TxAddInputDecodeErrorZ_is_ok(const struct LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR o);
18756 export function CResult_TxAddInputDecodeErrorZ_is_ok(o: bigint): boolean {
18757 if(!isWasmInitialized) {
18758 throw new Error("initializeWasm() must be awaited first!");
18760 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_is_ok(o);
18761 return nativeResponseValue;
18763 // void CResult_TxAddInputDecodeErrorZ_free(struct LDKCResult_TxAddInputDecodeErrorZ _res);
18765 export function CResult_TxAddInputDecodeErrorZ_free(_res: bigint): void {
18766 if(!isWasmInitialized) {
18767 throw new Error("initializeWasm() must be awaited first!");
18769 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_free(_res);
18770 // debug statements here
18772 // uint64_t CResult_TxAddInputDecodeErrorZ_clone_ptr(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR arg);
18774 export function CResult_TxAddInputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18775 if(!isWasmInitialized) {
18776 throw new Error("initializeWasm() must be awaited first!");
18778 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_clone_ptr(arg);
18779 return nativeResponseValue;
18781 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_clone(const struct LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR orig);
18783 export function CResult_TxAddInputDecodeErrorZ_clone(orig: bigint): bigint {
18784 if(!isWasmInitialized) {
18785 throw new Error("initializeWasm() must be awaited first!");
18787 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_clone(orig);
18788 return nativeResponseValue;
18790 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_ok(struct LDKTxAddOutput o);
18792 export function CResult_TxAddOutputDecodeErrorZ_ok(o: bigint): bigint {
18793 if(!isWasmInitialized) {
18794 throw new Error("initializeWasm() must be awaited first!");
18796 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_ok(o);
18797 return nativeResponseValue;
18799 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_err(struct LDKDecodeError e);
18801 export function CResult_TxAddOutputDecodeErrorZ_err(e: bigint): bigint {
18802 if(!isWasmInitialized) {
18803 throw new Error("initializeWasm() must be awaited first!");
18805 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_err(e);
18806 return nativeResponseValue;
18808 // bool CResult_TxAddOutputDecodeErrorZ_is_ok(const struct LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR o);
18810 export function CResult_TxAddOutputDecodeErrorZ_is_ok(o: bigint): boolean {
18811 if(!isWasmInitialized) {
18812 throw new Error("initializeWasm() must be awaited first!");
18814 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_is_ok(o);
18815 return nativeResponseValue;
18817 // void CResult_TxAddOutputDecodeErrorZ_free(struct LDKCResult_TxAddOutputDecodeErrorZ _res);
18819 export function CResult_TxAddOutputDecodeErrorZ_free(_res: bigint): void {
18820 if(!isWasmInitialized) {
18821 throw new Error("initializeWasm() must be awaited first!");
18823 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_free(_res);
18824 // debug statements here
18826 // uint64_t CResult_TxAddOutputDecodeErrorZ_clone_ptr(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR arg);
18828 export function CResult_TxAddOutputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18829 if(!isWasmInitialized) {
18830 throw new Error("initializeWasm() must be awaited first!");
18832 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_clone_ptr(arg);
18833 return nativeResponseValue;
18835 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_clone(const struct LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR orig);
18837 export function CResult_TxAddOutputDecodeErrorZ_clone(orig: bigint): bigint {
18838 if(!isWasmInitialized) {
18839 throw new Error("initializeWasm() must be awaited first!");
18841 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_clone(orig);
18842 return nativeResponseValue;
18844 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_ok(struct LDKTxRemoveInput o);
18846 export function CResult_TxRemoveInputDecodeErrorZ_ok(o: bigint): bigint {
18847 if(!isWasmInitialized) {
18848 throw new Error("initializeWasm() must be awaited first!");
18850 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_ok(o);
18851 return nativeResponseValue;
18853 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_err(struct LDKDecodeError e);
18855 export function CResult_TxRemoveInputDecodeErrorZ_err(e: bigint): bigint {
18856 if(!isWasmInitialized) {
18857 throw new Error("initializeWasm() must be awaited first!");
18859 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_err(e);
18860 return nativeResponseValue;
18862 // bool CResult_TxRemoveInputDecodeErrorZ_is_ok(const struct LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR o);
18864 export function CResult_TxRemoveInputDecodeErrorZ_is_ok(o: bigint): boolean {
18865 if(!isWasmInitialized) {
18866 throw new Error("initializeWasm() must be awaited first!");
18868 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_is_ok(o);
18869 return nativeResponseValue;
18871 // void CResult_TxRemoveInputDecodeErrorZ_free(struct LDKCResult_TxRemoveInputDecodeErrorZ _res);
18873 export function CResult_TxRemoveInputDecodeErrorZ_free(_res: bigint): void {
18874 if(!isWasmInitialized) {
18875 throw new Error("initializeWasm() must be awaited first!");
18877 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_free(_res);
18878 // debug statements here
18880 // uint64_t CResult_TxRemoveInputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR arg);
18882 export function CResult_TxRemoveInputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18883 if(!isWasmInitialized) {
18884 throw new Error("initializeWasm() must be awaited first!");
18886 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_clone_ptr(arg);
18887 return nativeResponseValue;
18889 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_clone(const struct LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR orig);
18891 export function CResult_TxRemoveInputDecodeErrorZ_clone(orig: bigint): bigint {
18892 if(!isWasmInitialized) {
18893 throw new Error("initializeWasm() must be awaited first!");
18895 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_clone(orig);
18896 return nativeResponseValue;
18898 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_ok(struct LDKTxRemoveOutput o);
18900 export function CResult_TxRemoveOutputDecodeErrorZ_ok(o: bigint): bigint {
18901 if(!isWasmInitialized) {
18902 throw new Error("initializeWasm() must be awaited first!");
18904 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_ok(o);
18905 return nativeResponseValue;
18907 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_err(struct LDKDecodeError e);
18909 export function CResult_TxRemoveOutputDecodeErrorZ_err(e: bigint): bigint {
18910 if(!isWasmInitialized) {
18911 throw new Error("initializeWasm() must be awaited first!");
18913 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_err(e);
18914 return nativeResponseValue;
18916 // bool CResult_TxRemoveOutputDecodeErrorZ_is_ok(const struct LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR o);
18918 export function CResult_TxRemoveOutputDecodeErrorZ_is_ok(o: bigint): boolean {
18919 if(!isWasmInitialized) {
18920 throw new Error("initializeWasm() must be awaited first!");
18922 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_is_ok(o);
18923 return nativeResponseValue;
18925 // void CResult_TxRemoveOutputDecodeErrorZ_free(struct LDKCResult_TxRemoveOutputDecodeErrorZ _res);
18927 export function CResult_TxRemoveOutputDecodeErrorZ_free(_res: bigint): void {
18928 if(!isWasmInitialized) {
18929 throw new Error("initializeWasm() must be awaited first!");
18931 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_free(_res);
18932 // debug statements here
18934 // uint64_t CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR arg);
18936 export function CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18937 if(!isWasmInitialized) {
18938 throw new Error("initializeWasm() must be awaited first!");
18940 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(arg);
18941 return nativeResponseValue;
18943 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_clone(const struct LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR orig);
18945 export function CResult_TxRemoveOutputDecodeErrorZ_clone(orig: bigint): bigint {
18946 if(!isWasmInitialized) {
18947 throw new Error("initializeWasm() must be awaited first!");
18949 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_clone(orig);
18950 return nativeResponseValue;
18952 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_ok(struct LDKTxComplete o);
18954 export function CResult_TxCompleteDecodeErrorZ_ok(o: bigint): bigint {
18955 if(!isWasmInitialized) {
18956 throw new Error("initializeWasm() must be awaited first!");
18958 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_ok(o);
18959 return nativeResponseValue;
18961 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_err(struct LDKDecodeError e);
18963 export function CResult_TxCompleteDecodeErrorZ_err(e: bigint): bigint {
18964 if(!isWasmInitialized) {
18965 throw new Error("initializeWasm() must be awaited first!");
18967 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_err(e);
18968 return nativeResponseValue;
18970 // bool CResult_TxCompleteDecodeErrorZ_is_ok(const struct LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR o);
18972 export function CResult_TxCompleteDecodeErrorZ_is_ok(o: bigint): boolean {
18973 if(!isWasmInitialized) {
18974 throw new Error("initializeWasm() must be awaited first!");
18976 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_is_ok(o);
18977 return nativeResponseValue;
18979 // void CResult_TxCompleteDecodeErrorZ_free(struct LDKCResult_TxCompleteDecodeErrorZ _res);
18981 export function CResult_TxCompleteDecodeErrorZ_free(_res: bigint): void {
18982 if(!isWasmInitialized) {
18983 throw new Error("initializeWasm() must be awaited first!");
18985 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_free(_res);
18986 // debug statements here
18988 // uint64_t CResult_TxCompleteDecodeErrorZ_clone_ptr(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR arg);
18990 export function CResult_TxCompleteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18991 if(!isWasmInitialized) {
18992 throw new Error("initializeWasm() must be awaited first!");
18994 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_clone_ptr(arg);
18995 return nativeResponseValue;
18997 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_clone(const struct LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR orig);
18999 export function CResult_TxCompleteDecodeErrorZ_clone(orig: bigint): bigint {
19000 if(!isWasmInitialized) {
19001 throw new Error("initializeWasm() must be awaited first!");
19003 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_clone(orig);
19004 return nativeResponseValue;
19006 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_ok(struct LDKTxSignatures o);
19008 export function CResult_TxSignaturesDecodeErrorZ_ok(o: bigint): bigint {
19009 if(!isWasmInitialized) {
19010 throw new Error("initializeWasm() must be awaited first!");
19012 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_ok(o);
19013 return nativeResponseValue;
19015 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
19017 export function CResult_TxSignaturesDecodeErrorZ_err(e: bigint): bigint {
19018 if(!isWasmInitialized) {
19019 throw new Error("initializeWasm() must be awaited first!");
19021 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_err(e);
19022 return nativeResponseValue;
19024 // bool CResult_TxSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR o);
19026 export function CResult_TxSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
19027 if(!isWasmInitialized) {
19028 throw new Error("initializeWasm() must be awaited first!");
19030 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_is_ok(o);
19031 return nativeResponseValue;
19033 // void CResult_TxSignaturesDecodeErrorZ_free(struct LDKCResult_TxSignaturesDecodeErrorZ _res);
19035 export function CResult_TxSignaturesDecodeErrorZ_free(_res: bigint): void {
19036 if(!isWasmInitialized) {
19037 throw new Error("initializeWasm() must be awaited first!");
19039 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_free(_res);
19040 // debug statements here
19042 // uint64_t CResult_TxSignaturesDecodeErrorZ_clone_ptr(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR arg);
19044 export function CResult_TxSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19045 if(!isWasmInitialized) {
19046 throw new Error("initializeWasm() must be awaited first!");
19048 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_clone_ptr(arg);
19049 return nativeResponseValue;
19051 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_clone(const struct LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR orig);
19053 export function CResult_TxSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
19054 if(!isWasmInitialized) {
19055 throw new Error("initializeWasm() must be awaited first!");
19057 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_clone(orig);
19058 return nativeResponseValue;
19060 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_ok(struct LDKTxInitRbf o);
19062 export function CResult_TxInitRbfDecodeErrorZ_ok(o: bigint): bigint {
19063 if(!isWasmInitialized) {
19064 throw new Error("initializeWasm() must be awaited first!");
19066 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_ok(o);
19067 return nativeResponseValue;
19069 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_err(struct LDKDecodeError e);
19071 export function CResult_TxInitRbfDecodeErrorZ_err(e: bigint): bigint {
19072 if(!isWasmInitialized) {
19073 throw new Error("initializeWasm() must be awaited first!");
19075 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_err(e);
19076 return nativeResponseValue;
19078 // bool CResult_TxInitRbfDecodeErrorZ_is_ok(const struct LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR o);
19080 export function CResult_TxInitRbfDecodeErrorZ_is_ok(o: bigint): boolean {
19081 if(!isWasmInitialized) {
19082 throw new Error("initializeWasm() must be awaited first!");
19084 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_is_ok(o);
19085 return nativeResponseValue;
19087 // void CResult_TxInitRbfDecodeErrorZ_free(struct LDKCResult_TxInitRbfDecodeErrorZ _res);
19089 export function CResult_TxInitRbfDecodeErrorZ_free(_res: bigint): void {
19090 if(!isWasmInitialized) {
19091 throw new Error("initializeWasm() must be awaited first!");
19093 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_free(_res);
19094 // debug statements here
19096 // uint64_t CResult_TxInitRbfDecodeErrorZ_clone_ptr(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR arg);
19098 export function CResult_TxInitRbfDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19099 if(!isWasmInitialized) {
19100 throw new Error("initializeWasm() must be awaited first!");
19102 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_clone_ptr(arg);
19103 return nativeResponseValue;
19105 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_clone(const struct LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR orig);
19107 export function CResult_TxInitRbfDecodeErrorZ_clone(orig: bigint): bigint {
19108 if(!isWasmInitialized) {
19109 throw new Error("initializeWasm() must be awaited first!");
19111 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_clone(orig);
19112 return nativeResponseValue;
19114 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_ok(struct LDKTxAckRbf o);
19116 export function CResult_TxAckRbfDecodeErrorZ_ok(o: bigint): bigint {
19117 if(!isWasmInitialized) {
19118 throw new Error("initializeWasm() must be awaited first!");
19120 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_ok(o);
19121 return nativeResponseValue;
19123 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_err(struct LDKDecodeError e);
19125 export function CResult_TxAckRbfDecodeErrorZ_err(e: bigint): bigint {
19126 if(!isWasmInitialized) {
19127 throw new Error("initializeWasm() must be awaited first!");
19129 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_err(e);
19130 return nativeResponseValue;
19132 // bool CResult_TxAckRbfDecodeErrorZ_is_ok(const struct LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR o);
19134 export function CResult_TxAckRbfDecodeErrorZ_is_ok(o: bigint): boolean {
19135 if(!isWasmInitialized) {
19136 throw new Error("initializeWasm() must be awaited first!");
19138 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_is_ok(o);
19139 return nativeResponseValue;
19141 // void CResult_TxAckRbfDecodeErrorZ_free(struct LDKCResult_TxAckRbfDecodeErrorZ _res);
19143 export function CResult_TxAckRbfDecodeErrorZ_free(_res: bigint): void {
19144 if(!isWasmInitialized) {
19145 throw new Error("initializeWasm() must be awaited first!");
19147 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_free(_res);
19148 // debug statements here
19150 // uint64_t CResult_TxAckRbfDecodeErrorZ_clone_ptr(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR arg);
19152 export function CResult_TxAckRbfDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19153 if(!isWasmInitialized) {
19154 throw new Error("initializeWasm() must be awaited first!");
19156 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_clone_ptr(arg);
19157 return nativeResponseValue;
19159 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_clone(const struct LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR orig);
19161 export function CResult_TxAckRbfDecodeErrorZ_clone(orig: bigint): bigint {
19162 if(!isWasmInitialized) {
19163 throw new Error("initializeWasm() must be awaited first!");
19165 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_clone(orig);
19166 return nativeResponseValue;
19168 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_ok(struct LDKTxAbort o);
19170 export function CResult_TxAbortDecodeErrorZ_ok(o: bigint): bigint {
19171 if(!isWasmInitialized) {
19172 throw new Error("initializeWasm() must be awaited first!");
19174 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_ok(o);
19175 return nativeResponseValue;
19177 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_err(struct LDKDecodeError e);
19179 export function CResult_TxAbortDecodeErrorZ_err(e: bigint): bigint {
19180 if(!isWasmInitialized) {
19181 throw new Error("initializeWasm() must be awaited first!");
19183 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_err(e);
19184 return nativeResponseValue;
19186 // bool CResult_TxAbortDecodeErrorZ_is_ok(const struct LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR o);
19188 export function CResult_TxAbortDecodeErrorZ_is_ok(o: bigint): boolean {
19189 if(!isWasmInitialized) {
19190 throw new Error("initializeWasm() must be awaited first!");
19192 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_is_ok(o);
19193 return nativeResponseValue;
19195 // void CResult_TxAbortDecodeErrorZ_free(struct LDKCResult_TxAbortDecodeErrorZ _res);
19197 export function CResult_TxAbortDecodeErrorZ_free(_res: bigint): void {
19198 if(!isWasmInitialized) {
19199 throw new Error("initializeWasm() must be awaited first!");
19201 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_free(_res);
19202 // debug statements here
19204 // uint64_t CResult_TxAbortDecodeErrorZ_clone_ptr(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR arg);
19206 export function CResult_TxAbortDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19207 if(!isWasmInitialized) {
19208 throw new Error("initializeWasm() must be awaited first!");
19210 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_clone_ptr(arg);
19211 return nativeResponseValue;
19213 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_clone(const struct LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR orig);
19215 export function CResult_TxAbortDecodeErrorZ_clone(orig: bigint): bigint {
19216 if(!isWasmInitialized) {
19217 throw new Error("initializeWasm() must be awaited first!");
19219 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_clone(orig);
19220 return nativeResponseValue;
19222 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
19224 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
19225 if(!isWasmInitialized) {
19226 throw new Error("initializeWasm() must be awaited first!");
19228 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
19229 return nativeResponseValue;
19231 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
19233 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
19234 if(!isWasmInitialized) {
19235 throw new Error("initializeWasm() must be awaited first!");
19237 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
19238 return nativeResponseValue;
19240 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
19242 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
19243 if(!isWasmInitialized) {
19244 throw new Error("initializeWasm() must be awaited first!");
19246 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
19247 return nativeResponseValue;
19249 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
19251 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
19252 if(!isWasmInitialized) {
19253 throw new Error("initializeWasm() must be awaited first!");
19255 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
19256 // debug statements here
19258 // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
19260 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19261 if(!isWasmInitialized) {
19262 throw new Error("initializeWasm() must be awaited first!");
19264 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
19265 return nativeResponseValue;
19267 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
19269 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
19270 if(!isWasmInitialized) {
19271 throw new Error("initializeWasm() must be awaited first!");
19273 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
19274 return nativeResponseValue;
19276 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
19278 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
19279 if(!isWasmInitialized) {
19280 throw new Error("initializeWasm() must be awaited first!");
19282 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
19283 return nativeResponseValue;
19285 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
19287 export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
19288 if(!isWasmInitialized) {
19289 throw new Error("initializeWasm() must be awaited first!");
19291 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
19292 return nativeResponseValue;
19294 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
19296 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
19297 if(!isWasmInitialized) {
19298 throw new Error("initializeWasm() must be awaited first!");
19300 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
19301 return nativeResponseValue;
19303 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
19305 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
19306 if(!isWasmInitialized) {
19307 throw new Error("initializeWasm() must be awaited first!");
19309 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
19310 // debug statements here
19312 // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
19314 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19315 if(!isWasmInitialized) {
19316 throw new Error("initializeWasm() must be awaited first!");
19318 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
19319 return nativeResponseValue;
19321 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
19323 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
19324 if(!isWasmInitialized) {
19325 throw new Error("initializeWasm() must be awaited first!");
19327 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
19328 return nativeResponseValue;
19330 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
19332 export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
19333 if(!isWasmInitialized) {
19334 throw new Error("initializeWasm() must be awaited first!");
19336 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
19337 return nativeResponseValue;
19339 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
19341 export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
19342 if(!isWasmInitialized) {
19343 throw new Error("initializeWasm() must be awaited first!");
19345 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
19346 return nativeResponseValue;
19348 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
19350 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
19351 if(!isWasmInitialized) {
19352 throw new Error("initializeWasm() must be awaited first!");
19354 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
19355 return nativeResponseValue;
19357 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
19359 export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
19360 if(!isWasmInitialized) {
19361 throw new Error("initializeWasm() must be awaited first!");
19363 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
19364 // debug statements here
19366 // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
19368 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19369 if(!isWasmInitialized) {
19370 throw new Error("initializeWasm() must be awaited first!");
19372 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
19373 return nativeResponseValue;
19375 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
19377 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
19378 if(!isWasmInitialized) {
19379 throw new Error("initializeWasm() must be awaited first!");
19381 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
19382 return nativeResponseValue;
19384 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
19386 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
19387 if(!isWasmInitialized) {
19388 throw new Error("initializeWasm() must be awaited first!");
19390 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
19391 return nativeResponseValue;
19393 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
19395 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
19396 if(!isWasmInitialized) {
19397 throw new Error("initializeWasm() must be awaited first!");
19399 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
19400 return nativeResponseValue;
19402 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
19404 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
19405 if(!isWasmInitialized) {
19406 throw new Error("initializeWasm() must be awaited first!");
19408 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
19409 return nativeResponseValue;
19411 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
19413 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
19414 if(!isWasmInitialized) {
19415 throw new Error("initializeWasm() must be awaited first!");
19417 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
19418 // debug statements here
19420 // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
19422 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19423 if(!isWasmInitialized) {
19424 throw new Error("initializeWasm() must be awaited first!");
19426 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
19427 return nativeResponseValue;
19429 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
19431 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
19432 if(!isWasmInitialized) {
19433 throw new Error("initializeWasm() must be awaited first!");
19435 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
19436 return nativeResponseValue;
19438 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
19440 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
19441 if(!isWasmInitialized) {
19442 throw new Error("initializeWasm() must be awaited first!");
19444 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
19445 return nativeResponseValue;
19447 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
19449 export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
19450 if(!isWasmInitialized) {
19451 throw new Error("initializeWasm() must be awaited first!");
19453 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
19454 return nativeResponseValue;
19456 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
19458 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
19459 if(!isWasmInitialized) {
19460 throw new Error("initializeWasm() must be awaited first!");
19462 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
19463 return nativeResponseValue;
19465 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
19467 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
19468 if(!isWasmInitialized) {
19469 throw new Error("initializeWasm() must be awaited first!");
19471 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
19472 // debug statements here
19474 // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
19476 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19477 if(!isWasmInitialized) {
19478 throw new Error("initializeWasm() must be awaited first!");
19480 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
19481 return nativeResponseValue;
19483 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
19485 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: bigint): bigint {
19486 if(!isWasmInitialized) {
19487 throw new Error("initializeWasm() must be awaited first!");
19489 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
19490 return nativeResponseValue;
19492 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
19494 export function CResult_FundingCreatedDecodeErrorZ_ok(o: bigint): bigint {
19495 if(!isWasmInitialized) {
19496 throw new Error("initializeWasm() must be awaited first!");
19498 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
19499 return nativeResponseValue;
19501 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
19503 export function CResult_FundingCreatedDecodeErrorZ_err(e: bigint): bigint {
19504 if(!isWasmInitialized) {
19505 throw new Error("initializeWasm() must be awaited first!");
19507 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
19508 return nativeResponseValue;
19510 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
19512 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: bigint): boolean {
19513 if(!isWasmInitialized) {
19514 throw new Error("initializeWasm() must be awaited first!");
19516 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
19517 return nativeResponseValue;
19519 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
19521 export function CResult_FundingCreatedDecodeErrorZ_free(_res: bigint): void {
19522 if(!isWasmInitialized) {
19523 throw new Error("initializeWasm() must be awaited first!");
19525 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
19526 // debug statements here
19528 // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
19530 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19531 if(!isWasmInitialized) {
19532 throw new Error("initializeWasm() must be awaited first!");
19534 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
19535 return nativeResponseValue;
19537 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
19539 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: bigint): bigint {
19540 if(!isWasmInitialized) {
19541 throw new Error("initializeWasm() must be awaited first!");
19543 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
19544 return nativeResponseValue;
19546 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
19548 export function CResult_FundingSignedDecodeErrorZ_ok(o: bigint): bigint {
19549 if(!isWasmInitialized) {
19550 throw new Error("initializeWasm() must be awaited first!");
19552 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
19553 return nativeResponseValue;
19555 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
19557 export function CResult_FundingSignedDecodeErrorZ_err(e: bigint): bigint {
19558 if(!isWasmInitialized) {
19559 throw new Error("initializeWasm() must be awaited first!");
19561 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
19562 return nativeResponseValue;
19564 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
19566 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
19567 if(!isWasmInitialized) {
19568 throw new Error("initializeWasm() must be awaited first!");
19570 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
19571 return nativeResponseValue;
19573 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
19575 export function CResult_FundingSignedDecodeErrorZ_free(_res: bigint): void {
19576 if(!isWasmInitialized) {
19577 throw new Error("initializeWasm() must be awaited first!");
19579 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
19580 // debug statements here
19582 // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
19584 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19585 if(!isWasmInitialized) {
19586 throw new Error("initializeWasm() must be awaited first!");
19588 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
19589 return nativeResponseValue;
19591 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
19593 export function CResult_FundingSignedDecodeErrorZ_clone(orig: bigint): bigint {
19594 if(!isWasmInitialized) {
19595 throw new Error("initializeWasm() must be awaited first!");
19597 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
19598 return nativeResponseValue;
19600 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
19602 export function CResult_ChannelReadyDecodeErrorZ_ok(o: bigint): bigint {
19603 if(!isWasmInitialized) {
19604 throw new Error("initializeWasm() must be awaited first!");
19606 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
19607 return nativeResponseValue;
19609 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
19611 export function CResult_ChannelReadyDecodeErrorZ_err(e: bigint): bigint {
19612 if(!isWasmInitialized) {
19613 throw new Error("initializeWasm() must be awaited first!");
19615 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
19616 return nativeResponseValue;
19618 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
19620 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: bigint): boolean {
19621 if(!isWasmInitialized) {
19622 throw new Error("initializeWasm() must be awaited first!");
19624 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
19625 return nativeResponseValue;
19627 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
19629 export function CResult_ChannelReadyDecodeErrorZ_free(_res: bigint): void {
19630 if(!isWasmInitialized) {
19631 throw new Error("initializeWasm() must be awaited first!");
19633 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
19634 // debug statements here
19636 // uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
19638 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19639 if(!isWasmInitialized) {
19640 throw new Error("initializeWasm() must be awaited first!");
19642 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
19643 return nativeResponseValue;
19645 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
19647 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: bigint): bigint {
19648 if(!isWasmInitialized) {
19649 throw new Error("initializeWasm() must be awaited first!");
19651 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
19652 return nativeResponseValue;
19654 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
19656 export function CResult_InitDecodeErrorZ_ok(o: bigint): bigint {
19657 if(!isWasmInitialized) {
19658 throw new Error("initializeWasm() must be awaited first!");
19660 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
19661 return nativeResponseValue;
19663 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
19665 export function CResult_InitDecodeErrorZ_err(e: bigint): bigint {
19666 if(!isWasmInitialized) {
19667 throw new Error("initializeWasm() must be awaited first!");
19669 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
19670 return nativeResponseValue;
19672 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
19674 export function CResult_InitDecodeErrorZ_is_ok(o: bigint): boolean {
19675 if(!isWasmInitialized) {
19676 throw new Error("initializeWasm() must be awaited first!");
19678 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
19679 return nativeResponseValue;
19681 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
19683 export function CResult_InitDecodeErrorZ_free(_res: bigint): void {
19684 if(!isWasmInitialized) {
19685 throw new Error("initializeWasm() must be awaited first!");
19687 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
19688 // debug statements here
19690 // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
19692 export function CResult_InitDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19693 if(!isWasmInitialized) {
19694 throw new Error("initializeWasm() must be awaited first!");
19696 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
19697 return nativeResponseValue;
19699 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
19701 export function CResult_InitDecodeErrorZ_clone(orig: bigint): bigint {
19702 if(!isWasmInitialized) {
19703 throw new Error("initializeWasm() must be awaited first!");
19705 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
19706 return nativeResponseValue;
19708 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
19710 export function CResult_OpenChannelDecodeErrorZ_ok(o: bigint): bigint {
19711 if(!isWasmInitialized) {
19712 throw new Error("initializeWasm() must be awaited first!");
19714 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
19715 return nativeResponseValue;
19717 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
19719 export function CResult_OpenChannelDecodeErrorZ_err(e: bigint): bigint {
19720 if(!isWasmInitialized) {
19721 throw new Error("initializeWasm() must be awaited first!");
19723 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
19724 return nativeResponseValue;
19726 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
19728 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: bigint): boolean {
19729 if(!isWasmInitialized) {
19730 throw new Error("initializeWasm() must be awaited first!");
19732 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
19733 return nativeResponseValue;
19735 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
19737 export function CResult_OpenChannelDecodeErrorZ_free(_res: bigint): void {
19738 if(!isWasmInitialized) {
19739 throw new Error("initializeWasm() must be awaited first!");
19741 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
19742 // debug statements here
19744 // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
19746 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19747 if(!isWasmInitialized) {
19748 throw new Error("initializeWasm() must be awaited first!");
19750 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
19751 return nativeResponseValue;
19753 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
19755 export function CResult_OpenChannelDecodeErrorZ_clone(orig: bigint): bigint {
19756 if(!isWasmInitialized) {
19757 throw new Error("initializeWasm() must be awaited first!");
19759 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
19760 return nativeResponseValue;
19762 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_ok(struct LDKOpenChannelV2 o);
19764 export function CResult_OpenChannelV2DecodeErrorZ_ok(o: bigint): bigint {
19765 if(!isWasmInitialized) {
19766 throw new Error("initializeWasm() must be awaited first!");
19768 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_ok(o);
19769 return nativeResponseValue;
19771 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_err(struct LDKDecodeError e);
19773 export function CResult_OpenChannelV2DecodeErrorZ_err(e: bigint): bigint {
19774 if(!isWasmInitialized) {
19775 throw new Error("initializeWasm() must be awaited first!");
19777 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_err(e);
19778 return nativeResponseValue;
19780 // bool CResult_OpenChannelV2DecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR o);
19782 export function CResult_OpenChannelV2DecodeErrorZ_is_ok(o: bigint): boolean {
19783 if(!isWasmInitialized) {
19784 throw new Error("initializeWasm() must be awaited first!");
19786 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_is_ok(o);
19787 return nativeResponseValue;
19789 // void CResult_OpenChannelV2DecodeErrorZ_free(struct LDKCResult_OpenChannelV2DecodeErrorZ _res);
19791 export function CResult_OpenChannelV2DecodeErrorZ_free(_res: bigint): void {
19792 if(!isWasmInitialized) {
19793 throw new Error("initializeWasm() must be awaited first!");
19795 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_free(_res);
19796 // debug statements here
19798 // uint64_t CResult_OpenChannelV2DecodeErrorZ_clone_ptr(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR arg);
19800 export function CResult_OpenChannelV2DecodeErrorZ_clone_ptr(arg: bigint): bigint {
19801 if(!isWasmInitialized) {
19802 throw new Error("initializeWasm() must be awaited first!");
19804 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_clone_ptr(arg);
19805 return nativeResponseValue;
19807 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_clone(const struct LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR orig);
19809 export function CResult_OpenChannelV2DecodeErrorZ_clone(orig: bigint): bigint {
19810 if(!isWasmInitialized) {
19811 throw new Error("initializeWasm() must be awaited first!");
19813 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_clone(orig);
19814 return nativeResponseValue;
19816 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
19818 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: bigint): bigint {
19819 if(!isWasmInitialized) {
19820 throw new Error("initializeWasm() must be awaited first!");
19822 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
19823 return nativeResponseValue;
19825 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
19827 export function CResult_RevokeAndACKDecodeErrorZ_err(e: bigint): bigint {
19828 if(!isWasmInitialized) {
19829 throw new Error("initializeWasm() must be awaited first!");
19831 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
19832 return nativeResponseValue;
19834 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
19836 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: bigint): boolean {
19837 if(!isWasmInitialized) {
19838 throw new Error("initializeWasm() must be awaited first!");
19840 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
19841 return nativeResponseValue;
19843 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
19845 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: bigint): void {
19846 if(!isWasmInitialized) {
19847 throw new Error("initializeWasm() must be awaited first!");
19849 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
19850 // debug statements here
19852 // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
19854 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19855 if(!isWasmInitialized) {
19856 throw new Error("initializeWasm() must be awaited first!");
19858 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
19859 return nativeResponseValue;
19861 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
19863 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: bigint): bigint {
19864 if(!isWasmInitialized) {
19865 throw new Error("initializeWasm() must be awaited first!");
19867 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
19868 return nativeResponseValue;
19870 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
19872 export function CResult_ShutdownDecodeErrorZ_ok(o: bigint): bigint {
19873 if(!isWasmInitialized) {
19874 throw new Error("initializeWasm() must be awaited first!");
19876 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
19877 return nativeResponseValue;
19879 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
19881 export function CResult_ShutdownDecodeErrorZ_err(e: bigint): bigint {
19882 if(!isWasmInitialized) {
19883 throw new Error("initializeWasm() must be awaited first!");
19885 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
19886 return nativeResponseValue;
19888 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
19890 export function CResult_ShutdownDecodeErrorZ_is_ok(o: bigint): boolean {
19891 if(!isWasmInitialized) {
19892 throw new Error("initializeWasm() must be awaited first!");
19894 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
19895 return nativeResponseValue;
19897 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
19899 export function CResult_ShutdownDecodeErrorZ_free(_res: bigint): void {
19900 if(!isWasmInitialized) {
19901 throw new Error("initializeWasm() must be awaited first!");
19903 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
19904 // debug statements here
19906 // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
19908 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19909 if(!isWasmInitialized) {
19910 throw new Error("initializeWasm() must be awaited first!");
19912 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
19913 return nativeResponseValue;
19915 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
19917 export function CResult_ShutdownDecodeErrorZ_clone(orig: bigint): bigint {
19918 if(!isWasmInitialized) {
19919 throw new Error("initializeWasm() must be awaited first!");
19921 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
19922 return nativeResponseValue;
19924 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
19926 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: bigint): bigint {
19927 if(!isWasmInitialized) {
19928 throw new Error("initializeWasm() must be awaited first!");
19930 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
19931 return nativeResponseValue;
19933 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
19935 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: bigint): bigint {
19936 if(!isWasmInitialized) {
19937 throw new Error("initializeWasm() must be awaited first!");
19939 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
19940 return nativeResponseValue;
19942 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
19944 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
19945 if(!isWasmInitialized) {
19946 throw new Error("initializeWasm() must be awaited first!");
19948 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
19949 return nativeResponseValue;
19951 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
19953 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: bigint): void {
19954 if(!isWasmInitialized) {
19955 throw new Error("initializeWasm() must be awaited first!");
19957 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
19958 // debug statements here
19960 // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
19962 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19963 if(!isWasmInitialized) {
19964 throw new Error("initializeWasm() must be awaited first!");
19966 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
19967 return nativeResponseValue;
19969 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
19971 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: bigint): bigint {
19972 if(!isWasmInitialized) {
19973 throw new Error("initializeWasm() must be awaited first!");
19975 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
19976 return nativeResponseValue;
19978 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
19980 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: bigint): bigint {
19981 if(!isWasmInitialized) {
19982 throw new Error("initializeWasm() must be awaited first!");
19984 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
19985 return nativeResponseValue;
19987 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
19989 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: bigint): bigint {
19990 if(!isWasmInitialized) {
19991 throw new Error("initializeWasm() must be awaited first!");
19993 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
19994 return nativeResponseValue;
19996 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
19998 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
19999 if(!isWasmInitialized) {
20000 throw new Error("initializeWasm() must be awaited first!");
20002 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
20003 return nativeResponseValue;
20005 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
20007 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: bigint): void {
20008 if(!isWasmInitialized) {
20009 throw new Error("initializeWasm() must be awaited first!");
20011 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
20012 // debug statements here
20014 // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
20016 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20017 if(!isWasmInitialized) {
20018 throw new Error("initializeWasm() must be awaited first!");
20020 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
20021 return nativeResponseValue;
20023 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
20025 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
20026 if(!isWasmInitialized) {
20027 throw new Error("initializeWasm() must be awaited first!");
20029 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
20030 return nativeResponseValue;
20032 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
20034 export function CResult_UpdateFeeDecodeErrorZ_ok(o: bigint): bigint {
20035 if(!isWasmInitialized) {
20036 throw new Error("initializeWasm() must be awaited first!");
20038 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
20039 return nativeResponseValue;
20041 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
20043 export function CResult_UpdateFeeDecodeErrorZ_err(e: bigint): bigint {
20044 if(!isWasmInitialized) {
20045 throw new Error("initializeWasm() must be awaited first!");
20047 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
20048 return nativeResponseValue;
20050 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
20052 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: bigint): boolean {
20053 if(!isWasmInitialized) {
20054 throw new Error("initializeWasm() must be awaited first!");
20056 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
20057 return nativeResponseValue;
20059 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
20061 export function CResult_UpdateFeeDecodeErrorZ_free(_res: bigint): void {
20062 if(!isWasmInitialized) {
20063 throw new Error("initializeWasm() must be awaited first!");
20065 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
20066 // debug statements here
20068 // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
20070 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20071 if(!isWasmInitialized) {
20072 throw new Error("initializeWasm() must be awaited first!");
20074 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
20075 return nativeResponseValue;
20077 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
20079 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: bigint): bigint {
20080 if(!isWasmInitialized) {
20081 throw new Error("initializeWasm() must be awaited first!");
20083 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
20084 return nativeResponseValue;
20086 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
20088 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: bigint): bigint {
20089 if(!isWasmInitialized) {
20090 throw new Error("initializeWasm() must be awaited first!");
20092 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
20093 return nativeResponseValue;
20095 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
20097 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: bigint): bigint {
20098 if(!isWasmInitialized) {
20099 throw new Error("initializeWasm() must be awaited first!");
20101 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
20102 return nativeResponseValue;
20104 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
20106 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
20107 if(!isWasmInitialized) {
20108 throw new Error("initializeWasm() must be awaited first!");
20110 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
20111 return nativeResponseValue;
20113 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
20115 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: bigint): void {
20116 if(!isWasmInitialized) {
20117 throw new Error("initializeWasm() must be awaited first!");
20119 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
20120 // debug statements here
20122 // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
20124 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20125 if(!isWasmInitialized) {
20126 throw new Error("initializeWasm() must be awaited first!");
20128 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
20129 return nativeResponseValue;
20131 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
20133 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: bigint): bigint {
20134 if(!isWasmInitialized) {
20135 throw new Error("initializeWasm() must be awaited first!");
20137 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
20138 return nativeResponseValue;
20140 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
20142 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: bigint): bigint {
20143 if(!isWasmInitialized) {
20144 throw new Error("initializeWasm() must be awaited first!");
20146 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
20147 return nativeResponseValue;
20149 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
20151 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: bigint): bigint {
20152 if(!isWasmInitialized) {
20153 throw new Error("initializeWasm() must be awaited first!");
20155 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
20156 return nativeResponseValue;
20158 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
20160 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
20161 if(!isWasmInitialized) {
20162 throw new Error("initializeWasm() must be awaited first!");
20164 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
20165 return nativeResponseValue;
20167 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
20169 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: bigint): void {
20170 if(!isWasmInitialized) {
20171 throw new Error("initializeWasm() must be awaited first!");
20173 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
20174 // debug statements here
20176 // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
20178 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20179 if(!isWasmInitialized) {
20180 throw new Error("initializeWasm() must be awaited first!");
20182 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
20183 return nativeResponseValue;
20185 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
20187 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: bigint): bigint {
20188 if(!isWasmInitialized) {
20189 throw new Error("initializeWasm() must be awaited first!");
20191 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
20192 return nativeResponseValue;
20194 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_ok(struct LDKOnionMessage o);
20196 export function CResult_OnionMessageDecodeErrorZ_ok(o: bigint): bigint {
20197 if(!isWasmInitialized) {
20198 throw new Error("initializeWasm() must be awaited first!");
20200 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_ok(o);
20201 return nativeResponseValue;
20203 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_err(struct LDKDecodeError e);
20205 export function CResult_OnionMessageDecodeErrorZ_err(e: bigint): bigint {
20206 if(!isWasmInitialized) {
20207 throw new Error("initializeWasm() must be awaited first!");
20209 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_err(e);
20210 return nativeResponseValue;
20212 // bool CResult_OnionMessageDecodeErrorZ_is_ok(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR o);
20214 export function CResult_OnionMessageDecodeErrorZ_is_ok(o: bigint): boolean {
20215 if(!isWasmInitialized) {
20216 throw new Error("initializeWasm() must be awaited first!");
20218 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_is_ok(o);
20219 return nativeResponseValue;
20221 // void CResult_OnionMessageDecodeErrorZ_free(struct LDKCResult_OnionMessageDecodeErrorZ _res);
20223 export function CResult_OnionMessageDecodeErrorZ_free(_res: bigint): void {
20224 if(!isWasmInitialized) {
20225 throw new Error("initializeWasm() must be awaited first!");
20227 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_free(_res);
20228 // debug statements here
20230 // uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg);
20232 export function CResult_OnionMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20233 if(!isWasmInitialized) {
20234 throw new Error("initializeWasm() must be awaited first!");
20236 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(arg);
20237 return nativeResponseValue;
20239 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_clone(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR orig);
20241 export function CResult_OnionMessageDecodeErrorZ_clone(orig: bigint): bigint {
20242 if(!isWasmInitialized) {
20243 throw new Error("initializeWasm() must be awaited first!");
20245 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone(orig);
20246 return nativeResponseValue;
20248 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
20250 export function CResult_PingDecodeErrorZ_ok(o: bigint): bigint {
20251 if(!isWasmInitialized) {
20252 throw new Error("initializeWasm() must be awaited first!");
20254 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
20255 return nativeResponseValue;
20257 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
20259 export function CResult_PingDecodeErrorZ_err(e: bigint): bigint {
20260 if(!isWasmInitialized) {
20261 throw new Error("initializeWasm() must be awaited first!");
20263 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
20264 return nativeResponseValue;
20266 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
20268 export function CResult_PingDecodeErrorZ_is_ok(o: bigint): boolean {
20269 if(!isWasmInitialized) {
20270 throw new Error("initializeWasm() must be awaited first!");
20272 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
20273 return nativeResponseValue;
20275 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
20277 export function CResult_PingDecodeErrorZ_free(_res: bigint): void {
20278 if(!isWasmInitialized) {
20279 throw new Error("initializeWasm() must be awaited first!");
20281 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
20282 // debug statements here
20284 // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
20286 export function CResult_PingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20287 if(!isWasmInitialized) {
20288 throw new Error("initializeWasm() must be awaited first!");
20290 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
20291 return nativeResponseValue;
20293 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
20295 export function CResult_PingDecodeErrorZ_clone(orig: bigint): bigint {
20296 if(!isWasmInitialized) {
20297 throw new Error("initializeWasm() must be awaited first!");
20299 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
20300 return nativeResponseValue;
20302 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
20304 export function CResult_PongDecodeErrorZ_ok(o: bigint): bigint {
20305 if(!isWasmInitialized) {
20306 throw new Error("initializeWasm() must be awaited first!");
20308 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
20309 return nativeResponseValue;
20311 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
20313 export function CResult_PongDecodeErrorZ_err(e: bigint): bigint {
20314 if(!isWasmInitialized) {
20315 throw new Error("initializeWasm() must be awaited first!");
20317 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
20318 return nativeResponseValue;
20320 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
20322 export function CResult_PongDecodeErrorZ_is_ok(o: bigint): boolean {
20323 if(!isWasmInitialized) {
20324 throw new Error("initializeWasm() must be awaited first!");
20326 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
20327 return nativeResponseValue;
20329 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
20331 export function CResult_PongDecodeErrorZ_free(_res: bigint): void {
20332 if(!isWasmInitialized) {
20333 throw new Error("initializeWasm() must be awaited first!");
20335 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
20336 // debug statements here
20338 // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
20340 export function CResult_PongDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20341 if(!isWasmInitialized) {
20342 throw new Error("initializeWasm() must be awaited first!");
20344 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
20345 return nativeResponseValue;
20347 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
20349 export function CResult_PongDecodeErrorZ_clone(orig: bigint): bigint {
20350 if(!isWasmInitialized) {
20351 throw new Error("initializeWasm() must be awaited first!");
20353 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
20354 return nativeResponseValue;
20356 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
20358 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
20359 if(!isWasmInitialized) {
20360 throw new Error("initializeWasm() must be awaited first!");
20362 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
20363 return nativeResponseValue;
20365 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
20367 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
20368 if(!isWasmInitialized) {
20369 throw new Error("initializeWasm() must be awaited first!");
20371 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
20372 return nativeResponseValue;
20374 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
20376 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
20377 if(!isWasmInitialized) {
20378 throw new Error("initializeWasm() must be awaited first!");
20380 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
20381 return nativeResponseValue;
20383 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
20385 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
20386 if(!isWasmInitialized) {
20387 throw new Error("initializeWasm() must be awaited first!");
20389 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
20390 // debug statements here
20392 // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
20394 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20395 if(!isWasmInitialized) {
20396 throw new Error("initializeWasm() must be awaited first!");
20398 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
20399 return nativeResponseValue;
20401 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
20403 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
20404 if(!isWasmInitialized) {
20405 throw new Error("initializeWasm() must be awaited first!");
20407 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
20408 return nativeResponseValue;
20410 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
20412 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
20413 if(!isWasmInitialized) {
20414 throw new Error("initializeWasm() must be awaited first!");
20416 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
20417 return nativeResponseValue;
20419 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
20421 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
20422 if(!isWasmInitialized) {
20423 throw new Error("initializeWasm() must be awaited first!");
20425 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
20426 return nativeResponseValue;
20428 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
20430 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
20431 if(!isWasmInitialized) {
20432 throw new Error("initializeWasm() must be awaited first!");
20434 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
20435 return nativeResponseValue;
20437 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
20439 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
20440 if(!isWasmInitialized) {
20441 throw new Error("initializeWasm() must be awaited first!");
20443 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
20444 // debug statements here
20446 // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
20448 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20449 if(!isWasmInitialized) {
20450 throw new Error("initializeWasm() must be awaited first!");
20452 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
20453 return nativeResponseValue;
20455 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
20457 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
20458 if(!isWasmInitialized) {
20459 throw new Error("initializeWasm() must be awaited first!");
20461 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
20462 return nativeResponseValue;
20464 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
20466 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
20467 if(!isWasmInitialized) {
20468 throw new Error("initializeWasm() must be awaited first!");
20470 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
20471 return nativeResponseValue;
20473 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
20475 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
20476 if(!isWasmInitialized) {
20477 throw new Error("initializeWasm() must be awaited first!");
20479 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
20480 return nativeResponseValue;
20482 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
20484 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
20485 if(!isWasmInitialized) {
20486 throw new Error("initializeWasm() must be awaited first!");
20488 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
20489 return nativeResponseValue;
20491 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
20493 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: bigint): void {
20494 if(!isWasmInitialized) {
20495 throw new Error("initializeWasm() must be awaited first!");
20497 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
20498 // debug statements here
20500 // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
20502 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20503 if(!isWasmInitialized) {
20504 throw new Error("initializeWasm() must be awaited first!");
20506 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
20507 return nativeResponseValue;
20509 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
20511 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
20512 if(!isWasmInitialized) {
20513 throw new Error("initializeWasm() must be awaited first!");
20515 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
20516 return nativeResponseValue;
20518 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
20520 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
20521 if(!isWasmInitialized) {
20522 throw new Error("initializeWasm() must be awaited first!");
20524 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
20525 return nativeResponseValue;
20527 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
20529 export function CResult_ChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
20530 if(!isWasmInitialized) {
20531 throw new Error("initializeWasm() must be awaited first!");
20533 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
20534 return nativeResponseValue;
20536 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
20538 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
20539 if(!isWasmInitialized) {
20540 throw new Error("initializeWasm() must be awaited first!");
20542 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
20543 return nativeResponseValue;
20545 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
20547 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: bigint): void {
20548 if(!isWasmInitialized) {
20549 throw new Error("initializeWasm() must be awaited first!");
20551 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
20552 // debug statements here
20554 // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
20556 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20557 if(!isWasmInitialized) {
20558 throw new Error("initializeWasm() must be awaited first!");
20560 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
20561 return nativeResponseValue;
20563 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
20565 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
20566 if(!isWasmInitialized) {
20567 throw new Error("initializeWasm() must be awaited first!");
20569 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
20570 return nativeResponseValue;
20572 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
20574 export function CResult_ErrorMessageDecodeErrorZ_ok(o: bigint): bigint {
20575 if(!isWasmInitialized) {
20576 throw new Error("initializeWasm() must be awaited first!");
20578 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
20579 return nativeResponseValue;
20581 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
20583 export function CResult_ErrorMessageDecodeErrorZ_err(e: bigint): bigint {
20584 if(!isWasmInitialized) {
20585 throw new Error("initializeWasm() must be awaited first!");
20587 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
20588 return nativeResponseValue;
20590 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
20592 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: bigint): boolean {
20593 if(!isWasmInitialized) {
20594 throw new Error("initializeWasm() must be awaited first!");
20596 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
20597 return nativeResponseValue;
20599 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
20601 export function CResult_ErrorMessageDecodeErrorZ_free(_res: bigint): void {
20602 if(!isWasmInitialized) {
20603 throw new Error("initializeWasm() must be awaited first!");
20605 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
20606 // debug statements here
20608 // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
20610 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20611 if(!isWasmInitialized) {
20612 throw new Error("initializeWasm() must be awaited first!");
20614 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
20615 return nativeResponseValue;
20617 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
20619 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: bigint): bigint {
20620 if(!isWasmInitialized) {
20621 throw new Error("initializeWasm() must be awaited first!");
20623 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
20624 return nativeResponseValue;
20626 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
20628 export function CResult_WarningMessageDecodeErrorZ_ok(o: bigint): bigint {
20629 if(!isWasmInitialized) {
20630 throw new Error("initializeWasm() must be awaited first!");
20632 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
20633 return nativeResponseValue;
20635 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
20637 export function CResult_WarningMessageDecodeErrorZ_err(e: bigint): bigint {
20638 if(!isWasmInitialized) {
20639 throw new Error("initializeWasm() must be awaited first!");
20641 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
20642 return nativeResponseValue;
20644 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
20646 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: bigint): boolean {
20647 if(!isWasmInitialized) {
20648 throw new Error("initializeWasm() must be awaited first!");
20650 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
20651 return nativeResponseValue;
20653 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
20655 export function CResult_WarningMessageDecodeErrorZ_free(_res: bigint): void {
20656 if(!isWasmInitialized) {
20657 throw new Error("initializeWasm() must be awaited first!");
20659 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
20660 // debug statements here
20662 // uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
20664 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20665 if(!isWasmInitialized) {
20666 throw new Error("initializeWasm() must be awaited first!");
20668 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
20669 return nativeResponseValue;
20671 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
20673 export function CResult_WarningMessageDecodeErrorZ_clone(orig: bigint): bigint {
20674 if(!isWasmInitialized) {
20675 throw new Error("initializeWasm() must be awaited first!");
20677 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
20678 return nativeResponseValue;
20680 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
20682 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
20683 if(!isWasmInitialized) {
20684 throw new Error("initializeWasm() must be awaited first!");
20686 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
20687 return nativeResponseValue;
20689 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
20691 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
20692 if(!isWasmInitialized) {
20693 throw new Error("initializeWasm() must be awaited first!");
20695 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
20696 return nativeResponseValue;
20698 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
20700 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
20701 if(!isWasmInitialized) {
20702 throw new Error("initializeWasm() must be awaited first!");
20704 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
20705 return nativeResponseValue;
20707 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
20709 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
20710 if(!isWasmInitialized) {
20711 throw new Error("initializeWasm() must be awaited first!");
20713 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
20714 // debug statements here
20716 // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
20718 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20719 if(!isWasmInitialized) {
20720 throw new Error("initializeWasm() must be awaited first!");
20722 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
20723 return nativeResponseValue;
20725 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
20727 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
20728 if(!isWasmInitialized) {
20729 throw new Error("initializeWasm() must be awaited first!");
20731 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
20732 return nativeResponseValue;
20734 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
20736 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
20737 if(!isWasmInitialized) {
20738 throw new Error("initializeWasm() must be awaited first!");
20740 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
20741 return nativeResponseValue;
20743 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
20745 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
20746 if(!isWasmInitialized) {
20747 throw new Error("initializeWasm() must be awaited first!");
20749 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
20750 return nativeResponseValue;
20752 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
20754 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
20755 if(!isWasmInitialized) {
20756 throw new Error("initializeWasm() must be awaited first!");
20758 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
20759 return nativeResponseValue;
20761 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
20763 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
20764 if(!isWasmInitialized) {
20765 throw new Error("initializeWasm() must be awaited first!");
20767 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
20768 // debug statements here
20770 // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
20772 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20773 if(!isWasmInitialized) {
20774 throw new Error("initializeWasm() must be awaited first!");
20776 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
20777 return nativeResponseValue;
20779 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
20781 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
20782 if(!isWasmInitialized) {
20783 throw new Error("initializeWasm() must be awaited first!");
20785 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
20786 return nativeResponseValue;
20788 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
20790 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: bigint): bigint {
20791 if(!isWasmInitialized) {
20792 throw new Error("initializeWasm() must be awaited first!");
20794 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
20795 return nativeResponseValue;
20797 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
20799 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: bigint): bigint {
20800 if(!isWasmInitialized) {
20801 throw new Error("initializeWasm() must be awaited first!");
20803 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
20804 return nativeResponseValue;
20806 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
20808 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: bigint): boolean {
20809 if(!isWasmInitialized) {
20810 throw new Error("initializeWasm() must be awaited first!");
20812 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
20813 return nativeResponseValue;
20815 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
20817 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: bigint): void {
20818 if(!isWasmInitialized) {
20819 throw new Error("initializeWasm() must be awaited first!");
20821 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
20822 // debug statements here
20824 // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
20826 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20827 if(!isWasmInitialized) {
20828 throw new Error("initializeWasm() must be awaited first!");
20830 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
20831 return nativeResponseValue;
20833 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
20835 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: bigint): bigint {
20836 if(!isWasmInitialized) {
20837 throw new Error("initializeWasm() must be awaited first!");
20839 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
20840 return nativeResponseValue;
20842 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
20844 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: bigint): bigint {
20845 if(!isWasmInitialized) {
20846 throw new Error("initializeWasm() must be awaited first!");
20848 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
20849 return nativeResponseValue;
20851 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
20853 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: bigint): bigint {
20854 if(!isWasmInitialized) {
20855 throw new Error("initializeWasm() must be awaited first!");
20857 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
20858 return nativeResponseValue;
20860 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
20862 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: bigint): boolean {
20863 if(!isWasmInitialized) {
20864 throw new Error("initializeWasm() must be awaited first!");
20866 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
20867 return nativeResponseValue;
20869 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
20871 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: bigint): void {
20872 if(!isWasmInitialized) {
20873 throw new Error("initializeWasm() must be awaited first!");
20875 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
20876 // debug statements here
20878 // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
20880 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20881 if(!isWasmInitialized) {
20882 throw new Error("initializeWasm() must be awaited first!");
20884 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
20885 return nativeResponseValue;
20887 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
20889 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: bigint): bigint {
20890 if(!isWasmInitialized) {
20891 throw new Error("initializeWasm() must be awaited first!");
20893 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
20894 return nativeResponseValue;
20896 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
20898 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
20899 if(!isWasmInitialized) {
20900 throw new Error("initializeWasm() must be awaited first!");
20902 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
20903 return nativeResponseValue;
20905 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
20907 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: bigint): bigint {
20908 if(!isWasmInitialized) {
20909 throw new Error("initializeWasm() must be awaited first!");
20911 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
20912 return nativeResponseValue;
20914 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
20916 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
20917 if(!isWasmInitialized) {
20918 throw new Error("initializeWasm() must be awaited first!");
20920 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
20921 return nativeResponseValue;
20923 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
20925 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: bigint): void {
20926 if(!isWasmInitialized) {
20927 throw new Error("initializeWasm() must be awaited first!");
20929 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
20930 // debug statements here
20932 // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
20934 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20935 if(!isWasmInitialized) {
20936 throw new Error("initializeWasm() must be awaited first!");
20938 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
20939 return nativeResponseValue;
20941 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
20943 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
20944 if(!isWasmInitialized) {
20945 throw new Error("initializeWasm() must be awaited first!");
20947 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
20948 return nativeResponseValue;
20950 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
20952 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
20953 if(!isWasmInitialized) {
20954 throw new Error("initializeWasm() must be awaited first!");
20956 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
20957 return nativeResponseValue;
20959 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
20961 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: bigint): bigint {
20962 if(!isWasmInitialized) {
20963 throw new Error("initializeWasm() must be awaited first!");
20965 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
20966 return nativeResponseValue;
20968 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
20970 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
20971 if(!isWasmInitialized) {
20972 throw new Error("initializeWasm() must be awaited first!");
20974 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
20975 return nativeResponseValue;
20977 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
20979 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: bigint): void {
20980 if(!isWasmInitialized) {
20981 throw new Error("initializeWasm() must be awaited first!");
20983 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
20984 // debug statements here
20986 // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
20988 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20989 if(!isWasmInitialized) {
20990 throw new Error("initializeWasm() must be awaited first!");
20992 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
20993 return nativeResponseValue;
20995 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
20997 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
20998 if(!isWasmInitialized) {
20999 throw new Error("initializeWasm() must be awaited first!");
21001 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
21002 return nativeResponseValue;
21004 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
21006 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: bigint): bigint {
21007 if(!isWasmInitialized) {
21008 throw new Error("initializeWasm() must be awaited first!");
21010 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
21011 return nativeResponseValue;
21013 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
21015 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: bigint): bigint {
21016 if(!isWasmInitialized) {
21017 throw new Error("initializeWasm() must be awaited first!");
21019 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
21020 return nativeResponseValue;
21022 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
21024 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: bigint): boolean {
21025 if(!isWasmInitialized) {
21026 throw new Error("initializeWasm() must be awaited first!");
21028 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
21029 return nativeResponseValue;
21031 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
21033 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: bigint): void {
21034 if(!isWasmInitialized) {
21035 throw new Error("initializeWasm() must be awaited first!");
21037 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
21038 // debug statements here
21040 // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
21042 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21043 if(!isWasmInitialized) {
21044 throw new Error("initializeWasm() must be awaited first!");
21046 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
21047 return nativeResponseValue;
21049 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
21051 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: bigint): bigint {
21052 if(!isWasmInitialized) {
21053 throw new Error("initializeWasm() must be awaited first!");
21055 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
21056 return nativeResponseValue;
21058 // void CVec_PhantomRouteHintsZ_free(struct LDKCVec_PhantomRouteHintsZ _res);
21060 export function CVec_PhantomRouteHintsZ_free(_res: number): void {
21061 if(!isWasmInitialized) {
21062 throw new Error("initializeWasm() must be awaited first!");
21064 const nativeResponseValue = wasm.TS_CVec_PhantomRouteHintsZ_free(_res);
21065 // debug statements here
21067 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(struct LDKBolt11Invoice o);
21069 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
21070 if(!isWasmInitialized) {
21071 throw new Error("initializeWasm() must be awaited first!");
21073 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(o);
21074 return nativeResponseValue;
21076 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
21078 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
21079 if(!isWasmInitialized) {
21080 throw new Error("initializeWasm() must be awaited first!");
21082 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_err(e);
21083 return nativeResponseValue;
21085 // bool CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
21087 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
21088 if(!isWasmInitialized) {
21089 throw new Error("initializeWasm() must be awaited first!");
21091 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(o);
21092 return nativeResponseValue;
21094 // void CResult_Bolt11InvoiceSignOrCreationErrorZ_free(struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ _res);
21096 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
21097 if(!isWasmInitialized) {
21098 throw new Error("initializeWasm() must be awaited first!");
21100 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_free(_res);
21101 // debug statements here
21103 // uint64_t CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
21105 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
21106 if(!isWasmInitialized) {
21107 throw new Error("initializeWasm() must be awaited first!");
21109 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(arg);
21110 return nativeResponseValue;
21112 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
21114 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
21115 if(!isWasmInitialized) {
21116 throw new Error("initializeWasm() must be awaited first!");
21118 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig);
21119 return nativeResponseValue;
21121 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_ok(struct LDKOffersMessage o);
21123 export function CResult_OffersMessageDecodeErrorZ_ok(o: bigint): bigint {
21124 if(!isWasmInitialized) {
21125 throw new Error("initializeWasm() must be awaited first!");
21127 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_ok(o);
21128 return nativeResponseValue;
21130 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_err(struct LDKDecodeError e);
21132 export function CResult_OffersMessageDecodeErrorZ_err(e: bigint): bigint {
21133 if(!isWasmInitialized) {
21134 throw new Error("initializeWasm() must be awaited first!");
21136 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_err(e);
21137 return nativeResponseValue;
21139 // bool CResult_OffersMessageDecodeErrorZ_is_ok(const struct LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR o);
21141 export function CResult_OffersMessageDecodeErrorZ_is_ok(o: bigint): boolean {
21142 if(!isWasmInitialized) {
21143 throw new Error("initializeWasm() must be awaited first!");
21145 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_is_ok(o);
21146 return nativeResponseValue;
21148 // void CResult_OffersMessageDecodeErrorZ_free(struct LDKCResult_OffersMessageDecodeErrorZ _res);
21150 export function CResult_OffersMessageDecodeErrorZ_free(_res: bigint): void {
21151 if(!isWasmInitialized) {
21152 throw new Error("initializeWasm() must be awaited first!");
21154 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_free(_res);
21155 // debug statements here
21157 // uint64_t CResult_OffersMessageDecodeErrorZ_clone_ptr(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR arg);
21159 export function CResult_OffersMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21160 if(!isWasmInitialized) {
21161 throw new Error("initializeWasm() must be awaited first!");
21163 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_clone_ptr(arg);
21164 return nativeResponseValue;
21166 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_clone(const struct LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR orig);
21168 export function CResult_OffersMessageDecodeErrorZ_clone(orig: bigint): bigint {
21169 if(!isWasmInitialized) {
21170 throw new Error("initializeWasm() must be awaited first!");
21172 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_clone(orig);
21173 return nativeResponseValue;
21175 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_some(enum LDKHTLCClaim o);
21177 export function COption_HTLCClaimZ_some(o: HTLCClaim): bigint {
21178 if(!isWasmInitialized) {
21179 throw new Error("initializeWasm() must be awaited first!");
21181 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_some(o);
21182 return nativeResponseValue;
21184 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_none(void);
21186 export function COption_HTLCClaimZ_none(): bigint {
21187 if(!isWasmInitialized) {
21188 throw new Error("initializeWasm() must be awaited first!");
21190 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_none();
21191 return nativeResponseValue;
21193 // void COption_HTLCClaimZ_free(struct LDKCOption_HTLCClaimZ _res);
21195 export function COption_HTLCClaimZ_free(_res: bigint): void {
21196 if(!isWasmInitialized) {
21197 throw new Error("initializeWasm() must be awaited first!");
21199 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_free(_res);
21200 // debug statements here
21202 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
21204 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: bigint): bigint {
21205 if(!isWasmInitialized) {
21206 throw new Error("initializeWasm() must be awaited first!");
21208 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
21209 return nativeResponseValue;
21211 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
21213 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: bigint): bigint {
21214 if(!isWasmInitialized) {
21215 throw new Error("initializeWasm() must be awaited first!");
21217 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
21218 return nativeResponseValue;
21220 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
21222 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: bigint): boolean {
21223 if(!isWasmInitialized) {
21224 throw new Error("initializeWasm() must be awaited first!");
21226 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
21227 return nativeResponseValue;
21229 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
21231 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: bigint): void {
21232 if(!isWasmInitialized) {
21233 throw new Error("initializeWasm() must be awaited first!");
21235 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
21236 // debug statements here
21238 // uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
21240 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21241 if(!isWasmInitialized) {
21242 throw new Error("initializeWasm() must be awaited first!");
21244 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
21245 return nativeResponseValue;
21247 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
21249 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: bigint): bigint {
21250 if(!isWasmInitialized) {
21251 throw new Error("initializeWasm() must be awaited first!");
21253 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
21254 return nativeResponseValue;
21256 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
21258 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: bigint): bigint {
21259 if(!isWasmInitialized) {
21260 throw new Error("initializeWasm() must be awaited first!");
21262 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
21263 return nativeResponseValue;
21265 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
21267 export function CResult_TxCreationKeysDecodeErrorZ_err(e: bigint): bigint {
21268 if(!isWasmInitialized) {
21269 throw new Error("initializeWasm() must be awaited first!");
21271 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
21272 return nativeResponseValue;
21274 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
21276 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: bigint): boolean {
21277 if(!isWasmInitialized) {
21278 throw new Error("initializeWasm() must be awaited first!");
21280 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
21281 return nativeResponseValue;
21283 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
21285 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: bigint): void {
21286 if(!isWasmInitialized) {
21287 throw new Error("initializeWasm() must be awaited first!");
21289 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
21290 // debug statements here
21292 // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
21294 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21295 if(!isWasmInitialized) {
21296 throw new Error("initializeWasm() must be awaited first!");
21298 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
21299 return nativeResponseValue;
21301 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
21303 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: bigint): bigint {
21304 if(!isWasmInitialized) {
21305 throw new Error("initializeWasm() must be awaited first!");
21307 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
21308 return nativeResponseValue;
21310 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
21312 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: bigint): bigint {
21313 if(!isWasmInitialized) {
21314 throw new Error("initializeWasm() must be awaited first!");
21316 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
21317 return nativeResponseValue;
21319 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
21321 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: bigint): bigint {
21322 if(!isWasmInitialized) {
21323 throw new Error("initializeWasm() must be awaited first!");
21325 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
21326 return nativeResponseValue;
21328 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
21330 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: bigint): boolean {
21331 if(!isWasmInitialized) {
21332 throw new Error("initializeWasm() must be awaited first!");
21334 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
21335 return nativeResponseValue;
21337 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
21339 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: bigint): void {
21340 if(!isWasmInitialized) {
21341 throw new Error("initializeWasm() must be awaited first!");
21343 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
21344 // debug statements here
21346 // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
21348 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21349 if(!isWasmInitialized) {
21350 throw new Error("initializeWasm() must be awaited first!");
21352 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
21353 return nativeResponseValue;
21355 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
21357 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: bigint): bigint {
21358 if(!isWasmInitialized) {
21359 throw new Error("initializeWasm() must be awaited first!");
21361 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
21362 return nativeResponseValue;
21364 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
21366 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: bigint): bigint {
21367 if(!isWasmInitialized) {
21368 throw new Error("initializeWasm() must be awaited first!");
21370 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
21371 return nativeResponseValue;
21373 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
21375 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: bigint): bigint {
21376 if(!isWasmInitialized) {
21377 throw new Error("initializeWasm() must be awaited first!");
21379 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
21380 return nativeResponseValue;
21382 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
21384 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: bigint): boolean {
21385 if(!isWasmInitialized) {
21386 throw new Error("initializeWasm() must be awaited first!");
21388 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
21389 return nativeResponseValue;
21391 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
21393 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: bigint): void {
21394 if(!isWasmInitialized) {
21395 throw new Error("initializeWasm() must be awaited first!");
21397 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
21398 // debug statements here
21400 // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
21402 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21403 if(!isWasmInitialized) {
21404 throw new Error("initializeWasm() must be awaited first!");
21406 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
21407 return nativeResponseValue;
21409 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
21411 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: bigint): bigint {
21412 if(!isWasmInitialized) {
21413 throw new Error("initializeWasm() must be awaited first!");
21415 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
21416 return nativeResponseValue;
21418 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
21420 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
21421 if(!isWasmInitialized) {
21422 throw new Error("initializeWasm() must be awaited first!");
21424 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
21425 return nativeResponseValue;
21427 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
21429 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
21430 if(!isWasmInitialized) {
21431 throw new Error("initializeWasm() must be awaited first!");
21433 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
21434 return nativeResponseValue;
21436 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
21438 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
21439 if(!isWasmInitialized) {
21440 throw new Error("initializeWasm() must be awaited first!");
21442 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
21443 return nativeResponseValue;
21445 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
21447 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
21448 if(!isWasmInitialized) {
21449 throw new Error("initializeWasm() must be awaited first!");
21451 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
21452 // debug statements here
21454 // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
21456 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21457 if(!isWasmInitialized) {
21458 throw new Error("initializeWasm() must be awaited first!");
21460 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
21461 return nativeResponseValue;
21463 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
21465 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
21466 if(!isWasmInitialized) {
21467 throw new Error("initializeWasm() must be awaited first!");
21469 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
21470 return nativeResponseValue;
21472 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
21474 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
21475 if(!isWasmInitialized) {
21476 throw new Error("initializeWasm() must be awaited first!");
21478 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
21479 return nativeResponseValue;
21481 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
21483 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
21484 if(!isWasmInitialized) {
21485 throw new Error("initializeWasm() must be awaited first!");
21487 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
21488 return nativeResponseValue;
21490 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
21492 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
21493 if(!isWasmInitialized) {
21494 throw new Error("initializeWasm() must be awaited first!");
21496 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
21497 return nativeResponseValue;
21499 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
21501 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
21502 if(!isWasmInitialized) {
21503 throw new Error("initializeWasm() must be awaited first!");
21505 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
21506 // debug statements here
21508 // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
21510 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21511 if(!isWasmInitialized) {
21512 throw new Error("initializeWasm() must be awaited first!");
21514 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
21515 return nativeResponseValue;
21517 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
21519 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
21520 if(!isWasmInitialized) {
21521 throw new Error("initializeWasm() must be awaited first!");
21523 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
21524 return nativeResponseValue;
21526 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
21528 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
21529 if(!isWasmInitialized) {
21530 throw new Error("initializeWasm() must be awaited first!");
21532 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
21533 return nativeResponseValue;
21535 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
21537 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
21538 if(!isWasmInitialized) {
21539 throw new Error("initializeWasm() must be awaited first!");
21541 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
21542 return nativeResponseValue;
21544 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
21546 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
21547 if(!isWasmInitialized) {
21548 throw new Error("initializeWasm() must be awaited first!");
21550 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
21551 return nativeResponseValue;
21553 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
21555 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
21556 if(!isWasmInitialized) {
21557 throw new Error("initializeWasm() must be awaited first!");
21559 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
21560 // debug statements here
21562 // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
21564 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21565 if(!isWasmInitialized) {
21566 throw new Error("initializeWasm() must be awaited first!");
21568 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
21569 return nativeResponseValue;
21571 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
21573 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
21574 if(!isWasmInitialized) {
21575 throw new Error("initializeWasm() must be awaited first!");
21577 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
21578 return nativeResponseValue;
21580 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
21582 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
21583 if(!isWasmInitialized) {
21584 throw new Error("initializeWasm() must be awaited first!");
21586 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
21587 return nativeResponseValue;
21589 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
21591 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
21592 if(!isWasmInitialized) {
21593 throw new Error("initializeWasm() must be awaited first!");
21595 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
21596 return nativeResponseValue;
21598 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
21600 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
21601 if(!isWasmInitialized) {
21602 throw new Error("initializeWasm() must be awaited first!");
21604 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
21605 return nativeResponseValue;
21607 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
21609 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
21610 if(!isWasmInitialized) {
21611 throw new Error("initializeWasm() must be awaited first!");
21613 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
21614 // debug statements here
21616 // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
21618 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21619 if(!isWasmInitialized) {
21620 throw new Error("initializeWasm() must be awaited first!");
21622 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
21623 return nativeResponseValue;
21625 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
21627 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
21628 if(!isWasmInitialized) {
21629 throw new Error("initializeWasm() must be awaited first!");
21631 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
21632 return nativeResponseValue;
21634 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
21636 export function CResult_TrustedClosingTransactionNoneZ_ok(o: bigint): bigint {
21637 if(!isWasmInitialized) {
21638 throw new Error("initializeWasm() must be awaited first!");
21640 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
21641 return nativeResponseValue;
21643 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
21645 export function CResult_TrustedClosingTransactionNoneZ_err(): bigint {
21646 if(!isWasmInitialized) {
21647 throw new Error("initializeWasm() must be awaited first!");
21649 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
21650 return nativeResponseValue;
21652 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
21654 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: bigint): boolean {
21655 if(!isWasmInitialized) {
21656 throw new Error("initializeWasm() must be awaited first!");
21658 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
21659 return nativeResponseValue;
21661 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
21663 export function CResult_TrustedClosingTransactionNoneZ_free(_res: bigint): void {
21664 if(!isWasmInitialized) {
21665 throw new Error("initializeWasm() must be awaited first!");
21667 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
21668 // debug statements here
21670 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
21672 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
21673 if(!isWasmInitialized) {
21674 throw new Error("initializeWasm() must be awaited first!");
21676 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
21677 return nativeResponseValue;
21679 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
21681 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
21682 if(!isWasmInitialized) {
21683 throw new Error("initializeWasm() must be awaited first!");
21685 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
21686 return nativeResponseValue;
21688 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
21690 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
21691 if(!isWasmInitialized) {
21692 throw new Error("initializeWasm() must be awaited first!");
21694 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
21695 return nativeResponseValue;
21697 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
21699 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
21700 if(!isWasmInitialized) {
21701 throw new Error("initializeWasm() must be awaited first!");
21703 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
21704 // debug statements here
21706 // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
21708 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21709 if(!isWasmInitialized) {
21710 throw new Error("initializeWasm() must be awaited first!");
21712 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
21713 return nativeResponseValue;
21715 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
21717 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
21718 if(!isWasmInitialized) {
21719 throw new Error("initializeWasm() must be awaited first!");
21721 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
21722 return nativeResponseValue;
21724 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
21726 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: bigint): bigint {
21727 if(!isWasmInitialized) {
21728 throw new Error("initializeWasm() must be awaited first!");
21730 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
21731 return nativeResponseValue;
21733 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
21735 export function CResult_TrustedCommitmentTransactionNoneZ_err(): bigint {
21736 if(!isWasmInitialized) {
21737 throw new Error("initializeWasm() must be awaited first!");
21739 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
21740 return nativeResponseValue;
21742 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
21744 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: bigint): boolean {
21745 if(!isWasmInitialized) {
21746 throw new Error("initializeWasm() must be awaited first!");
21748 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
21749 return nativeResponseValue;
21751 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
21753 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: bigint): void {
21754 if(!isWasmInitialized) {
21755 throw new Error("initializeWasm() must be awaited first!");
21757 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
21758 // debug statements here
21760 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_ok(struct LDKCVec_ECDSASignatureZ o);
21762 export function CResult_CVec_ECDSASignatureZNoneZ_ok(o: number): bigint {
21763 if(!isWasmInitialized) {
21764 throw new Error("initializeWasm() must be awaited first!");
21766 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_ok(o);
21767 return nativeResponseValue;
21769 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_err(void);
21771 export function CResult_CVec_ECDSASignatureZNoneZ_err(): bigint {
21772 if(!isWasmInitialized) {
21773 throw new Error("initializeWasm() must be awaited first!");
21775 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_err();
21776 return nativeResponseValue;
21778 // bool CResult_CVec_ECDSASignatureZNoneZ_is_ok(const struct LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR o);
21780 export function CResult_CVec_ECDSASignatureZNoneZ_is_ok(o: bigint): boolean {
21781 if(!isWasmInitialized) {
21782 throw new Error("initializeWasm() must be awaited first!");
21784 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_is_ok(o);
21785 return nativeResponseValue;
21787 // void CResult_CVec_ECDSASignatureZNoneZ_free(struct LDKCResult_CVec_ECDSASignatureZNoneZ _res);
21789 export function CResult_CVec_ECDSASignatureZNoneZ_free(_res: bigint): void {
21790 if(!isWasmInitialized) {
21791 throw new Error("initializeWasm() must be awaited first!");
21793 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_free(_res);
21794 // debug statements here
21796 // uint64_t CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR arg);
21798 export function CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(arg: bigint): bigint {
21799 if(!isWasmInitialized) {
21800 throw new Error("initializeWasm() must be awaited first!");
21802 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(arg);
21803 return nativeResponseValue;
21805 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_clone(const struct LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR orig);
21807 export function CResult_CVec_ECDSASignatureZNoneZ_clone(orig: bigint): bigint {
21808 if(!isWasmInitialized) {
21809 throw new Error("initializeWasm() must be awaited first!");
21811 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_clone(orig);
21812 return nativeResponseValue;
21814 // struct LDKCOption_usizeZ COption_usizeZ_some(uintptr_t o);
21816 export function COption_usizeZ_some(o: number): bigint {
21817 if(!isWasmInitialized) {
21818 throw new Error("initializeWasm() must be awaited first!");
21820 const nativeResponseValue = wasm.TS_COption_usizeZ_some(o);
21821 return nativeResponseValue;
21823 // struct LDKCOption_usizeZ COption_usizeZ_none(void);
21825 export function COption_usizeZ_none(): bigint {
21826 if(!isWasmInitialized) {
21827 throw new Error("initializeWasm() must be awaited first!");
21829 const nativeResponseValue = wasm.TS_COption_usizeZ_none();
21830 return nativeResponseValue;
21832 // void COption_usizeZ_free(struct LDKCOption_usizeZ _res);
21834 export function COption_usizeZ_free(_res: bigint): void {
21835 if(!isWasmInitialized) {
21836 throw new Error("initializeWasm() must be awaited first!");
21838 const nativeResponseValue = wasm.TS_COption_usizeZ_free(_res);
21839 // debug statements here
21841 // uint64_t COption_usizeZ_clone_ptr(LDKCOption_usizeZ *NONNULL_PTR arg);
21843 export function COption_usizeZ_clone_ptr(arg: bigint): bigint {
21844 if(!isWasmInitialized) {
21845 throw new Error("initializeWasm() must be awaited first!");
21847 const nativeResponseValue = wasm.TS_COption_usizeZ_clone_ptr(arg);
21848 return nativeResponseValue;
21850 // struct LDKCOption_usizeZ COption_usizeZ_clone(const struct LDKCOption_usizeZ *NONNULL_PTR orig);
21852 export function COption_usizeZ_clone(orig: bigint): bigint {
21853 if(!isWasmInitialized) {
21854 throw new Error("initializeWasm() must be awaited first!");
21856 const nativeResponseValue = wasm.TS_COption_usizeZ_clone(orig);
21857 return nativeResponseValue;
21859 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
21861 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: bigint): bigint {
21862 if(!isWasmInitialized) {
21863 throw new Error("initializeWasm() must be awaited first!");
21865 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
21866 return nativeResponseValue;
21868 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
21870 export function CResult_ShutdownScriptDecodeErrorZ_err(e: bigint): bigint {
21871 if(!isWasmInitialized) {
21872 throw new Error("initializeWasm() must be awaited first!");
21874 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
21875 return nativeResponseValue;
21877 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
21879 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: bigint): boolean {
21880 if(!isWasmInitialized) {
21881 throw new Error("initializeWasm() must be awaited first!");
21883 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
21884 return nativeResponseValue;
21886 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
21888 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: bigint): void {
21889 if(!isWasmInitialized) {
21890 throw new Error("initializeWasm() must be awaited first!");
21892 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
21893 // debug statements here
21895 // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
21897 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21898 if(!isWasmInitialized) {
21899 throw new Error("initializeWasm() must be awaited first!");
21901 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
21902 return nativeResponseValue;
21904 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
21906 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: bigint): bigint {
21907 if(!isWasmInitialized) {
21908 throw new Error("initializeWasm() must be awaited first!");
21910 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
21911 return nativeResponseValue;
21913 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
21915 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: bigint): bigint {
21916 if(!isWasmInitialized) {
21917 throw new Error("initializeWasm() must be awaited first!");
21919 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
21920 return nativeResponseValue;
21922 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
21924 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: bigint): bigint {
21925 if(!isWasmInitialized) {
21926 throw new Error("initializeWasm() must be awaited first!");
21928 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
21929 return nativeResponseValue;
21931 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
21933 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: bigint): boolean {
21934 if(!isWasmInitialized) {
21935 throw new Error("initializeWasm() must be awaited first!");
21937 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
21938 return nativeResponseValue;
21940 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
21942 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: bigint): void {
21943 if(!isWasmInitialized) {
21944 throw new Error("initializeWasm() must be awaited first!");
21946 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
21947 // debug statements here
21949 // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
21951 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: bigint): bigint {
21952 if(!isWasmInitialized) {
21953 throw new Error("initializeWasm() must be awaited first!");
21955 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
21956 return nativeResponseValue;
21958 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
21960 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: bigint): bigint {
21961 if(!isWasmInitialized) {
21962 throw new Error("initializeWasm() must be awaited first!");
21964 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
21965 return nativeResponseValue;
21967 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
21969 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
21970 if(!isWasmInitialized) {
21971 throw new Error("initializeWasm() must be awaited first!");
21973 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
21974 return nativeResponseValue;
21976 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
21978 export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
21979 if(!isWasmInitialized) {
21980 throw new Error("initializeWasm() must be awaited first!");
21982 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
21983 return nativeResponseValue;
21985 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
21987 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
21988 if(!isWasmInitialized) {
21989 throw new Error("initializeWasm() must be awaited first!");
21991 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
21992 return nativeResponseValue;
21994 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
21996 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
21997 if(!isWasmInitialized) {
21998 throw new Error("initializeWasm() must be awaited first!");
22000 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
22001 // debug statements here
22003 // uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
22005 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22006 if(!isWasmInitialized) {
22007 throw new Error("initializeWasm() must be awaited first!");
22009 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
22010 return nativeResponseValue;
22012 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
22014 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
22015 if(!isWasmInitialized) {
22016 throw new Error("initializeWasm() must be awaited first!");
22018 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
22019 return nativeResponseValue;
22021 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_ok(struct LDKClaimedHTLC o);
22023 export function CResult_ClaimedHTLCDecodeErrorZ_ok(o: bigint): bigint {
22024 if(!isWasmInitialized) {
22025 throw new Error("initializeWasm() must be awaited first!");
22027 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_ok(o);
22028 return nativeResponseValue;
22030 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
22032 export function CResult_ClaimedHTLCDecodeErrorZ_err(e: bigint): bigint {
22033 if(!isWasmInitialized) {
22034 throw new Error("initializeWasm() must be awaited first!");
22036 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_err(e);
22037 return nativeResponseValue;
22039 // bool CResult_ClaimedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR o);
22041 export function CResult_ClaimedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
22042 if(!isWasmInitialized) {
22043 throw new Error("initializeWasm() must be awaited first!");
22045 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_is_ok(o);
22046 return nativeResponseValue;
22048 // void CResult_ClaimedHTLCDecodeErrorZ_free(struct LDKCResult_ClaimedHTLCDecodeErrorZ _res);
22050 export function CResult_ClaimedHTLCDecodeErrorZ_free(_res: bigint): void {
22051 if(!isWasmInitialized) {
22052 throw new Error("initializeWasm() must be awaited first!");
22054 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_free(_res);
22055 // debug statements here
22057 // uint64_t CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR arg);
22059 export function CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22060 if(!isWasmInitialized) {
22061 throw new Error("initializeWasm() must be awaited first!");
22063 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(arg);
22064 return nativeResponseValue;
22066 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_clone(const struct LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR orig);
22068 export function CResult_ClaimedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
22069 if(!isWasmInitialized) {
22070 throw new Error("initializeWasm() must be awaited first!");
22072 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_clone(orig);
22073 return nativeResponseValue;
22075 // struct LDKCOption_PathFailureZ COption_PathFailureZ_some(struct LDKPathFailure o);
22077 export function COption_PathFailureZ_some(o: bigint): bigint {
22078 if(!isWasmInitialized) {
22079 throw new Error("initializeWasm() must be awaited first!");
22081 const nativeResponseValue = wasm.TS_COption_PathFailureZ_some(o);
22082 return nativeResponseValue;
22084 // struct LDKCOption_PathFailureZ COption_PathFailureZ_none(void);
22086 export function COption_PathFailureZ_none(): bigint {
22087 if(!isWasmInitialized) {
22088 throw new Error("initializeWasm() must be awaited first!");
22090 const nativeResponseValue = wasm.TS_COption_PathFailureZ_none();
22091 return nativeResponseValue;
22093 // void COption_PathFailureZ_free(struct LDKCOption_PathFailureZ _res);
22095 export function COption_PathFailureZ_free(_res: bigint): void {
22096 if(!isWasmInitialized) {
22097 throw new Error("initializeWasm() must be awaited first!");
22099 const nativeResponseValue = wasm.TS_COption_PathFailureZ_free(_res);
22100 // debug statements here
22102 // uint64_t COption_PathFailureZ_clone_ptr(LDKCOption_PathFailureZ *NONNULL_PTR arg);
22104 export function COption_PathFailureZ_clone_ptr(arg: bigint): bigint {
22105 if(!isWasmInitialized) {
22106 throw new Error("initializeWasm() must be awaited first!");
22108 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone_ptr(arg);
22109 return nativeResponseValue;
22111 // struct LDKCOption_PathFailureZ COption_PathFailureZ_clone(const struct LDKCOption_PathFailureZ *NONNULL_PTR orig);
22113 export function COption_PathFailureZ_clone(orig: bigint): bigint {
22114 if(!isWasmInitialized) {
22115 throw new Error("initializeWasm() must be awaited first!");
22117 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone(orig);
22118 return nativeResponseValue;
22120 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_ok(struct LDKCOption_PathFailureZ o);
22122 export function CResult_COption_PathFailureZDecodeErrorZ_ok(o: bigint): bigint {
22123 if(!isWasmInitialized) {
22124 throw new Error("initializeWasm() must be awaited first!");
22126 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_ok(o);
22127 return nativeResponseValue;
22129 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_err(struct LDKDecodeError e);
22131 export function CResult_COption_PathFailureZDecodeErrorZ_err(e: bigint): bigint {
22132 if(!isWasmInitialized) {
22133 throw new Error("initializeWasm() must be awaited first!");
22135 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_err(e);
22136 return nativeResponseValue;
22138 // bool CResult_COption_PathFailureZDecodeErrorZ_is_ok(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR o);
22140 export function CResult_COption_PathFailureZDecodeErrorZ_is_ok(o: bigint): boolean {
22141 if(!isWasmInitialized) {
22142 throw new Error("initializeWasm() must be awaited first!");
22144 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok(o);
22145 return nativeResponseValue;
22147 // void CResult_COption_PathFailureZDecodeErrorZ_free(struct LDKCResult_COption_PathFailureZDecodeErrorZ _res);
22149 export function CResult_COption_PathFailureZDecodeErrorZ_free(_res: bigint): void {
22150 if(!isWasmInitialized) {
22151 throw new Error("initializeWasm() must be awaited first!");
22153 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_free(_res);
22154 // debug statements here
22156 // uint64_t CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR arg);
22158 export function CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22159 if(!isWasmInitialized) {
22160 throw new Error("initializeWasm() must be awaited first!");
22162 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg);
22163 return nativeResponseValue;
22165 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_clone(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR orig);
22167 export function CResult_COption_PathFailureZDecodeErrorZ_clone(orig: bigint): bigint {
22168 if(!isWasmInitialized) {
22169 throw new Error("initializeWasm() must be awaited first!");
22171 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone(orig);
22172 return nativeResponseValue;
22174 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
22176 export function COption_ClosureReasonZ_some(o: bigint): bigint {
22177 if(!isWasmInitialized) {
22178 throw new Error("initializeWasm() must be awaited first!");
22180 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
22181 return nativeResponseValue;
22183 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
22185 export function COption_ClosureReasonZ_none(): bigint {
22186 if(!isWasmInitialized) {
22187 throw new Error("initializeWasm() must be awaited first!");
22189 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
22190 return nativeResponseValue;
22192 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
22194 export function COption_ClosureReasonZ_free(_res: bigint): void {
22195 if(!isWasmInitialized) {
22196 throw new Error("initializeWasm() must be awaited first!");
22198 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
22199 // debug statements here
22201 // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
22203 export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
22204 if(!isWasmInitialized) {
22205 throw new Error("initializeWasm() must be awaited first!");
22207 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
22208 return nativeResponseValue;
22210 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
22212 export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
22213 if(!isWasmInitialized) {
22214 throw new Error("initializeWasm() must be awaited first!");
22216 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
22217 return nativeResponseValue;
22219 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
22221 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
22222 if(!isWasmInitialized) {
22223 throw new Error("initializeWasm() must be awaited first!");
22225 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
22226 return nativeResponseValue;
22228 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
22230 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
22231 if(!isWasmInitialized) {
22232 throw new Error("initializeWasm() must be awaited first!");
22234 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
22235 return nativeResponseValue;
22237 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
22239 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
22240 if(!isWasmInitialized) {
22241 throw new Error("initializeWasm() must be awaited first!");
22243 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
22244 return nativeResponseValue;
22246 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
22248 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
22249 if(!isWasmInitialized) {
22250 throw new Error("initializeWasm() must be awaited first!");
22252 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
22253 // debug statements here
22255 // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
22257 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22258 if(!isWasmInitialized) {
22259 throw new Error("initializeWasm() must be awaited first!");
22261 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
22262 return nativeResponseValue;
22264 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
22266 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
22267 if(!isWasmInitialized) {
22268 throw new Error("initializeWasm() must be awaited first!");
22270 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
22271 return nativeResponseValue;
22273 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
22275 export function COption_HTLCDestinationZ_some(o: bigint): bigint {
22276 if(!isWasmInitialized) {
22277 throw new Error("initializeWasm() must be awaited first!");
22279 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
22280 return nativeResponseValue;
22282 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
22284 export function COption_HTLCDestinationZ_none(): bigint {
22285 if(!isWasmInitialized) {
22286 throw new Error("initializeWasm() must be awaited first!");
22288 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
22289 return nativeResponseValue;
22291 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
22293 export function COption_HTLCDestinationZ_free(_res: bigint): void {
22294 if(!isWasmInitialized) {
22295 throw new Error("initializeWasm() must be awaited first!");
22297 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
22298 // debug statements here
22300 // uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
22302 export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
22303 if(!isWasmInitialized) {
22304 throw new Error("initializeWasm() must be awaited first!");
22306 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
22307 return nativeResponseValue;
22309 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
22311 export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
22312 if(!isWasmInitialized) {
22313 throw new Error("initializeWasm() must be awaited first!");
22315 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
22316 return nativeResponseValue;
22318 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
22320 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
22321 if(!isWasmInitialized) {
22322 throw new Error("initializeWasm() must be awaited first!");
22324 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
22325 return nativeResponseValue;
22327 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
22329 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
22330 if(!isWasmInitialized) {
22331 throw new Error("initializeWasm() must be awaited first!");
22333 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
22334 return nativeResponseValue;
22336 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
22338 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
22339 if(!isWasmInitialized) {
22340 throw new Error("initializeWasm() must be awaited first!");
22342 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
22343 return nativeResponseValue;
22345 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
22347 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
22348 if(!isWasmInitialized) {
22349 throw new Error("initializeWasm() must be awaited first!");
22351 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
22352 // debug statements here
22354 // uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
22356 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22357 if(!isWasmInitialized) {
22358 throw new Error("initializeWasm() must be awaited first!");
22360 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
22361 return nativeResponseValue;
22363 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
22365 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
22366 if(!isWasmInitialized) {
22367 throw new Error("initializeWasm() must be awaited first!");
22369 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
22370 return nativeResponseValue;
22372 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_ok(enum LDKPaymentFailureReason o);
22374 export function CResult_PaymentFailureReasonDecodeErrorZ_ok(o: PaymentFailureReason): bigint {
22375 if(!isWasmInitialized) {
22376 throw new Error("initializeWasm() must be awaited first!");
22378 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_ok(o);
22379 return nativeResponseValue;
22381 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_err(struct LDKDecodeError e);
22383 export function CResult_PaymentFailureReasonDecodeErrorZ_err(e: bigint): bigint {
22384 if(!isWasmInitialized) {
22385 throw new Error("initializeWasm() must be awaited first!");
22387 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_err(e);
22388 return nativeResponseValue;
22390 // bool CResult_PaymentFailureReasonDecodeErrorZ_is_ok(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR o);
22392 export function CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o: bigint): boolean {
22393 if(!isWasmInitialized) {
22394 throw new Error("initializeWasm() must be awaited first!");
22396 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o);
22397 return nativeResponseValue;
22399 // void CResult_PaymentFailureReasonDecodeErrorZ_free(struct LDKCResult_PaymentFailureReasonDecodeErrorZ _res);
22401 export function CResult_PaymentFailureReasonDecodeErrorZ_free(_res: bigint): void {
22402 if(!isWasmInitialized) {
22403 throw new Error("initializeWasm() must be awaited first!");
22405 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_free(_res);
22406 // debug statements here
22408 // uint64_t CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR arg);
22410 export function CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22411 if(!isWasmInitialized) {
22412 throw new Error("initializeWasm() must be awaited first!");
22414 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg);
22415 return nativeResponseValue;
22417 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_clone(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR orig);
22419 export function CResult_PaymentFailureReasonDecodeErrorZ_clone(orig: bigint): bigint {
22420 if(!isWasmInitialized) {
22421 throw new Error("initializeWasm() must be awaited first!");
22423 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone(orig);
22424 return nativeResponseValue;
22426 // struct LDKCOption_U128Z COption_U128Z_some(struct LDKU128 o);
22428 export function COption_U128Z_some(o: number): bigint {
22429 if(!isWasmInitialized) {
22430 throw new Error("initializeWasm() must be awaited first!");
22432 const nativeResponseValue = wasm.TS_COption_U128Z_some(o);
22433 return nativeResponseValue;
22435 // struct LDKCOption_U128Z COption_U128Z_none(void);
22437 export function COption_U128Z_none(): bigint {
22438 if(!isWasmInitialized) {
22439 throw new Error("initializeWasm() must be awaited first!");
22441 const nativeResponseValue = wasm.TS_COption_U128Z_none();
22442 return nativeResponseValue;
22444 // void COption_U128Z_free(struct LDKCOption_U128Z _res);
22446 export function COption_U128Z_free(_res: bigint): void {
22447 if(!isWasmInitialized) {
22448 throw new Error("initializeWasm() must be awaited first!");
22450 const nativeResponseValue = wasm.TS_COption_U128Z_free(_res);
22451 // debug statements here
22453 // uint64_t COption_U128Z_clone_ptr(LDKCOption_U128Z *NONNULL_PTR arg);
22455 export function COption_U128Z_clone_ptr(arg: bigint): bigint {
22456 if(!isWasmInitialized) {
22457 throw new Error("initializeWasm() must be awaited first!");
22459 const nativeResponseValue = wasm.TS_COption_U128Z_clone_ptr(arg);
22460 return nativeResponseValue;
22462 // struct LDKCOption_U128Z COption_U128Z_clone(const struct LDKCOption_U128Z *NONNULL_PTR orig);
22464 export function COption_U128Z_clone(orig: bigint): bigint {
22465 if(!isWasmInitialized) {
22466 throw new Error("initializeWasm() must be awaited first!");
22468 const nativeResponseValue = wasm.TS_COption_U128Z_clone(orig);
22469 return nativeResponseValue;
22471 // void CVec_ClaimedHTLCZ_free(struct LDKCVec_ClaimedHTLCZ _res);
22473 export function CVec_ClaimedHTLCZ_free(_res: number): void {
22474 if(!isWasmInitialized) {
22475 throw new Error("initializeWasm() must be awaited first!");
22477 const nativeResponseValue = wasm.TS_CVec_ClaimedHTLCZ_free(_res);
22478 // debug statements here
22480 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_some(enum LDKPaymentFailureReason o);
22482 export function COption_PaymentFailureReasonZ_some(o: PaymentFailureReason): bigint {
22483 if(!isWasmInitialized) {
22484 throw new Error("initializeWasm() must be awaited first!");
22486 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_some(o);
22487 return nativeResponseValue;
22489 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_none(void);
22491 export function COption_PaymentFailureReasonZ_none(): bigint {
22492 if(!isWasmInitialized) {
22493 throw new Error("initializeWasm() must be awaited first!");
22495 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_none();
22496 return nativeResponseValue;
22498 // void COption_PaymentFailureReasonZ_free(struct LDKCOption_PaymentFailureReasonZ _res);
22500 export function COption_PaymentFailureReasonZ_free(_res: bigint): void {
22501 if(!isWasmInitialized) {
22502 throw new Error("initializeWasm() must be awaited first!");
22504 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_free(_res);
22505 // debug statements here
22507 // uint64_t COption_PaymentFailureReasonZ_clone_ptr(LDKCOption_PaymentFailureReasonZ *NONNULL_PTR arg);
22509 export function COption_PaymentFailureReasonZ_clone_ptr(arg: bigint): bigint {
22510 if(!isWasmInitialized) {
22511 throw new Error("initializeWasm() must be awaited first!");
22513 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone_ptr(arg);
22514 return nativeResponseValue;
22516 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_clone(const struct LDKCOption_PaymentFailureReasonZ *NONNULL_PTR orig);
22518 export function COption_PaymentFailureReasonZ_clone(orig: bigint): bigint {
22519 if(!isWasmInitialized) {
22520 throw new Error("initializeWasm() must be awaited first!");
22522 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone(orig);
22523 return nativeResponseValue;
22525 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
22527 export function COption_EventZ_some(o: bigint): bigint {
22528 if(!isWasmInitialized) {
22529 throw new Error("initializeWasm() must be awaited first!");
22531 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
22532 return nativeResponseValue;
22534 // struct LDKCOption_EventZ COption_EventZ_none(void);
22536 export function COption_EventZ_none(): bigint {
22537 if(!isWasmInitialized) {
22538 throw new Error("initializeWasm() must be awaited first!");
22540 const nativeResponseValue = wasm.TS_COption_EventZ_none();
22541 return nativeResponseValue;
22543 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
22545 export function COption_EventZ_free(_res: bigint): void {
22546 if(!isWasmInitialized) {
22547 throw new Error("initializeWasm() must be awaited first!");
22549 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
22550 // debug statements here
22552 // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
22554 export function COption_EventZ_clone_ptr(arg: bigint): bigint {
22555 if(!isWasmInitialized) {
22556 throw new Error("initializeWasm() must be awaited first!");
22558 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
22559 return nativeResponseValue;
22561 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
22563 export function COption_EventZ_clone(orig: bigint): bigint {
22564 if(!isWasmInitialized) {
22565 throw new Error("initializeWasm() must be awaited first!");
22567 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
22568 return nativeResponseValue;
22570 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
22572 export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
22573 if(!isWasmInitialized) {
22574 throw new Error("initializeWasm() must be awaited first!");
22576 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
22577 return nativeResponseValue;
22579 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
22581 export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
22582 if(!isWasmInitialized) {
22583 throw new Error("initializeWasm() must be awaited first!");
22585 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
22586 return nativeResponseValue;
22588 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
22590 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
22591 if(!isWasmInitialized) {
22592 throw new Error("initializeWasm() must be awaited first!");
22594 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
22595 return nativeResponseValue;
22597 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
22599 export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
22600 if(!isWasmInitialized) {
22601 throw new Error("initializeWasm() must be awaited first!");
22603 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
22604 // debug statements here
22606 // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
22608 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22609 if(!isWasmInitialized) {
22610 throw new Error("initializeWasm() must be awaited first!");
22612 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
22613 return nativeResponseValue;
22615 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
22617 export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
22618 if(!isWasmInitialized) {
22619 throw new Error("initializeWasm() must be awaited first!");
22621 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
22622 return nativeResponseValue;
22624 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_ok(enum LDKSiPrefix o);
22626 export function CResult_SiPrefixBolt11ParseErrorZ_ok(o: SiPrefix): bigint {
22627 if(!isWasmInitialized) {
22628 throw new Error("initializeWasm() must be awaited first!");
22630 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_ok(o);
22631 return nativeResponseValue;
22633 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_err(struct LDKBolt11ParseError e);
22635 export function CResult_SiPrefixBolt11ParseErrorZ_err(e: bigint): bigint {
22636 if(!isWasmInitialized) {
22637 throw new Error("initializeWasm() must be awaited first!");
22639 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_err(e);
22640 return nativeResponseValue;
22642 // bool CResult_SiPrefixBolt11ParseErrorZ_is_ok(const struct LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR o);
22644 export function CResult_SiPrefixBolt11ParseErrorZ_is_ok(o: bigint): boolean {
22645 if(!isWasmInitialized) {
22646 throw new Error("initializeWasm() must be awaited first!");
22648 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_is_ok(o);
22649 return nativeResponseValue;
22651 // void CResult_SiPrefixBolt11ParseErrorZ_free(struct LDKCResult_SiPrefixBolt11ParseErrorZ _res);
22653 export function CResult_SiPrefixBolt11ParseErrorZ_free(_res: bigint): void {
22654 if(!isWasmInitialized) {
22655 throw new Error("initializeWasm() must be awaited first!");
22657 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_free(_res);
22658 // debug statements here
22660 // uint64_t CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR arg);
22662 export function CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(arg: bigint): bigint {
22663 if(!isWasmInitialized) {
22664 throw new Error("initializeWasm() must be awaited first!");
22666 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(arg);
22667 return nativeResponseValue;
22669 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_clone(const struct LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR orig);
22671 export function CResult_SiPrefixBolt11ParseErrorZ_clone(orig: bigint): bigint {
22672 if(!isWasmInitialized) {
22673 throw new Error("initializeWasm() must be awaited first!");
22675 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_clone(orig);
22676 return nativeResponseValue;
22678 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(struct LDKBolt11Invoice o);
22680 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
22681 if(!isWasmInitialized) {
22682 throw new Error("initializeWasm() must be awaited first!");
22684 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(o);
22685 return nativeResponseValue;
22687 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
22689 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
22690 if(!isWasmInitialized) {
22691 throw new Error("initializeWasm() must be awaited first!");
22693 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(e);
22694 return nativeResponseValue;
22696 // bool CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
22698 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
22699 if(!isWasmInitialized) {
22700 throw new Error("initializeWasm() must be awaited first!");
22702 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(o);
22703 return nativeResponseValue;
22705 // void CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ _res);
22707 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
22708 if(!isWasmInitialized) {
22709 throw new Error("initializeWasm() must be awaited first!");
22711 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(_res);
22712 // debug statements here
22714 // uint64_t CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
22716 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
22717 if(!isWasmInitialized) {
22718 throw new Error("initializeWasm() must be awaited first!");
22720 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
22721 return nativeResponseValue;
22723 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
22725 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
22726 if(!isWasmInitialized) {
22727 throw new Error("initializeWasm() must be awaited first!");
22729 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(orig);
22730 return nativeResponseValue;
22732 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(struct LDKSignedRawBolt11Invoice o);
22734 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(o: bigint): bigint {
22735 if(!isWasmInitialized) {
22736 throw new Error("initializeWasm() must be awaited first!");
22738 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(o);
22739 return nativeResponseValue;
22741 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(struct LDKBolt11ParseError e);
22743 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(e: bigint): bigint {
22744 if(!isWasmInitialized) {
22745 throw new Error("initializeWasm() must be awaited first!");
22747 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(e);
22748 return nativeResponseValue;
22750 // bool CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(const struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR o);
22752 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(o: bigint): boolean {
22753 if(!isWasmInitialized) {
22754 throw new Error("initializeWasm() must be awaited first!");
22756 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(o);
22757 return nativeResponseValue;
22759 // void CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ _res);
22761 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(_res: bigint): void {
22762 if(!isWasmInitialized) {
22763 throw new Error("initializeWasm() must be awaited first!");
22765 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(_res);
22766 // debug statements here
22768 // uint64_t CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR arg);
22770 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(arg: bigint): bigint {
22771 if(!isWasmInitialized) {
22772 throw new Error("initializeWasm() must be awaited first!");
22774 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(arg);
22775 return nativeResponseValue;
22777 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(const struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR orig);
22779 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(orig: bigint): bigint {
22780 if(!isWasmInitialized) {
22781 throw new Error("initializeWasm() must be awaited first!");
22783 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(orig);
22784 return nativeResponseValue;
22786 // uint64_t C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR arg);
22788 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
22789 if(!isWasmInitialized) {
22790 throw new Error("initializeWasm() must be awaited first!");
22792 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(arg);
22793 return nativeResponseValue;
22795 // struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR orig);
22797 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(orig: bigint): bigint {
22798 if(!isWasmInitialized) {
22799 throw new Error("initializeWasm() must be awaited first!");
22801 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(orig);
22802 return nativeResponseValue;
22804 // struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(struct LDKRawBolt11Invoice a, struct LDKThirtyTwoBytes b, struct LDKBolt11InvoiceSignature c);
22806 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
22807 if(!isWasmInitialized) {
22808 throw new Error("initializeWasm() must be awaited first!");
22810 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(a, b, c);
22811 return nativeResponseValue;
22813 // void C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ _res);
22815 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(_res: bigint): void {
22816 if(!isWasmInitialized) {
22817 throw new Error("initializeWasm() must be awaited first!");
22819 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(_res);
22820 // debug statements here
22822 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_ok(struct LDKPayeePubKey o);
22824 export function CResult_PayeePubKeySecp256k1ErrorZ_ok(o: bigint): bigint {
22825 if(!isWasmInitialized) {
22826 throw new Error("initializeWasm() must be awaited first!");
22828 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_ok(o);
22829 return nativeResponseValue;
22831 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
22833 export function CResult_PayeePubKeySecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
22834 if(!isWasmInitialized) {
22835 throw new Error("initializeWasm() must be awaited first!");
22837 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_err(e);
22838 return nativeResponseValue;
22840 // bool CResult_PayeePubKeySecp256k1ErrorZ_is_ok(const struct LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR o);
22842 export function CResult_PayeePubKeySecp256k1ErrorZ_is_ok(o: bigint): boolean {
22843 if(!isWasmInitialized) {
22844 throw new Error("initializeWasm() must be awaited first!");
22846 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_is_ok(o);
22847 return nativeResponseValue;
22849 // void CResult_PayeePubKeySecp256k1ErrorZ_free(struct LDKCResult_PayeePubKeySecp256k1ErrorZ _res);
22851 export function CResult_PayeePubKeySecp256k1ErrorZ_free(_res: bigint): void {
22852 if(!isWasmInitialized) {
22853 throw new Error("initializeWasm() must be awaited first!");
22855 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_free(_res);
22856 // debug statements here
22858 // uint64_t CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR arg);
22860 export function CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
22861 if(!isWasmInitialized) {
22862 throw new Error("initializeWasm() must be awaited first!");
22864 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(arg);
22865 return nativeResponseValue;
22867 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_clone(const struct LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR orig);
22869 export function CResult_PayeePubKeySecp256k1ErrorZ_clone(orig: bigint): bigint {
22870 if(!isWasmInitialized) {
22871 throw new Error("initializeWasm() must be awaited first!");
22873 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_clone(orig);
22874 return nativeResponseValue;
22876 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
22878 export function CVec_PrivateRouteZ_free(_res: number): void {
22879 if(!isWasmInitialized) {
22880 throw new Error("initializeWasm() must be awaited first!");
22882 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
22883 // debug statements here
22885 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
22887 export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
22888 if(!isWasmInitialized) {
22889 throw new Error("initializeWasm() must be awaited first!");
22891 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
22892 return nativeResponseValue;
22894 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
22896 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
22897 if(!isWasmInitialized) {
22898 throw new Error("initializeWasm() must be awaited first!");
22900 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
22901 return nativeResponseValue;
22903 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
22905 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
22906 if(!isWasmInitialized) {
22907 throw new Error("initializeWasm() must be awaited first!");
22909 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
22910 return nativeResponseValue;
22912 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
22914 export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
22915 if(!isWasmInitialized) {
22916 throw new Error("initializeWasm() must be awaited first!");
22918 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
22919 // debug statements here
22921 // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
22923 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
22924 if(!isWasmInitialized) {
22925 throw new Error("initializeWasm() must be awaited first!");
22927 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
22928 return nativeResponseValue;
22930 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
22932 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
22933 if(!isWasmInitialized) {
22934 throw new Error("initializeWasm() must be awaited first!");
22936 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
22937 return nativeResponseValue;
22939 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_ok(void);
22941 export function CResult_NoneBolt11SemanticErrorZ_ok(): bigint {
22942 if(!isWasmInitialized) {
22943 throw new Error("initializeWasm() must be awaited first!");
22945 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_ok();
22946 return nativeResponseValue;
22948 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_err(enum LDKBolt11SemanticError e);
22950 export function CResult_NoneBolt11SemanticErrorZ_err(e: Bolt11SemanticError): bigint {
22951 if(!isWasmInitialized) {
22952 throw new Error("initializeWasm() must be awaited first!");
22954 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_err(e);
22955 return nativeResponseValue;
22957 // bool CResult_NoneBolt11SemanticErrorZ_is_ok(const struct LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR o);
22959 export function CResult_NoneBolt11SemanticErrorZ_is_ok(o: bigint): boolean {
22960 if(!isWasmInitialized) {
22961 throw new Error("initializeWasm() must be awaited first!");
22963 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_is_ok(o);
22964 return nativeResponseValue;
22966 // void CResult_NoneBolt11SemanticErrorZ_free(struct LDKCResult_NoneBolt11SemanticErrorZ _res);
22968 export function CResult_NoneBolt11SemanticErrorZ_free(_res: bigint): void {
22969 if(!isWasmInitialized) {
22970 throw new Error("initializeWasm() must be awaited first!");
22972 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_free(_res);
22973 // debug statements here
22975 // uint64_t CResult_NoneBolt11SemanticErrorZ_clone_ptr(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR arg);
22977 export function CResult_NoneBolt11SemanticErrorZ_clone_ptr(arg: bigint): bigint {
22978 if(!isWasmInitialized) {
22979 throw new Error("initializeWasm() must be awaited first!");
22981 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_clone_ptr(arg);
22982 return nativeResponseValue;
22984 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_clone(const struct LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR orig);
22986 export function CResult_NoneBolt11SemanticErrorZ_clone(orig: bigint): bigint {
22987 if(!isWasmInitialized) {
22988 throw new Error("initializeWasm() must be awaited first!");
22990 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_clone(orig);
22991 return nativeResponseValue;
22993 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(struct LDKBolt11Invoice o);
22995 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(o: bigint): bigint {
22996 if(!isWasmInitialized) {
22997 throw new Error("initializeWasm() must be awaited first!");
22999 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(o);
23000 return nativeResponseValue;
23002 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(enum LDKBolt11SemanticError e);
23004 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(e: Bolt11SemanticError): bigint {
23005 if(!isWasmInitialized) {
23006 throw new Error("initializeWasm() must be awaited first!");
23008 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(e);
23009 return nativeResponseValue;
23011 // bool CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR o);
23013 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(o: bigint): boolean {
23014 if(!isWasmInitialized) {
23015 throw new Error("initializeWasm() must be awaited first!");
23017 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(o);
23018 return nativeResponseValue;
23020 // void CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ _res);
23022 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(_res: bigint): void {
23023 if(!isWasmInitialized) {
23024 throw new Error("initializeWasm() must be awaited first!");
23026 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(_res);
23027 // debug statements here
23029 // uint64_t CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR arg);
23031 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(arg: bigint): bigint {
23032 if(!isWasmInitialized) {
23033 throw new Error("initializeWasm() must be awaited first!");
23035 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(arg);
23036 return nativeResponseValue;
23038 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(const struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR orig);
23040 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(orig: bigint): bigint {
23041 if(!isWasmInitialized) {
23042 throw new Error("initializeWasm() must be awaited first!");
23044 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(orig);
23045 return nativeResponseValue;
23047 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
23049 export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
23050 if(!isWasmInitialized) {
23051 throw new Error("initializeWasm() must be awaited first!");
23053 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
23054 return nativeResponseValue;
23056 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
23058 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
23059 if(!isWasmInitialized) {
23060 throw new Error("initializeWasm() must be awaited first!");
23062 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
23063 return nativeResponseValue;
23065 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
23067 export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
23068 if(!isWasmInitialized) {
23069 throw new Error("initializeWasm() must be awaited first!");
23071 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
23072 return nativeResponseValue;
23074 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
23076 export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
23077 if(!isWasmInitialized) {
23078 throw new Error("initializeWasm() must be awaited first!");
23080 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
23081 // debug statements here
23083 // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
23085 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
23086 if(!isWasmInitialized) {
23087 throw new Error("initializeWasm() must be awaited first!");
23089 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
23090 return nativeResponseValue;
23092 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
23094 export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
23095 if(!isWasmInitialized) {
23096 throw new Error("initializeWasm() must be awaited first!");
23098 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
23099 return nativeResponseValue;
23101 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
23103 export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
23104 if(!isWasmInitialized) {
23105 throw new Error("initializeWasm() must be awaited first!");
23107 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
23108 return nativeResponseValue;
23110 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
23112 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
23113 if(!isWasmInitialized) {
23114 throw new Error("initializeWasm() must be awaited first!");
23116 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
23117 return nativeResponseValue;
23119 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
23121 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
23122 if(!isWasmInitialized) {
23123 throw new Error("initializeWasm() must be awaited first!");
23125 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
23126 return nativeResponseValue;
23128 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
23130 export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
23131 if(!isWasmInitialized) {
23132 throw new Error("initializeWasm() must be awaited first!");
23134 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
23135 // debug statements here
23137 // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
23139 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
23140 if(!isWasmInitialized) {
23141 throw new Error("initializeWasm() must be awaited first!");
23143 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
23144 return nativeResponseValue;
23146 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
23148 export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
23149 if(!isWasmInitialized) {
23150 throw new Error("initializeWasm() must be awaited first!");
23152 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
23153 return nativeResponseValue;
23155 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
23157 export function CResult_OutPointDecodeErrorZ_ok(o: bigint): bigint {
23158 if(!isWasmInitialized) {
23159 throw new Error("initializeWasm() must be awaited first!");
23161 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
23162 return nativeResponseValue;
23164 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
23166 export function CResult_OutPointDecodeErrorZ_err(e: bigint): bigint {
23167 if(!isWasmInitialized) {
23168 throw new Error("initializeWasm() must be awaited first!");
23170 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
23171 return nativeResponseValue;
23173 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
23175 export function CResult_OutPointDecodeErrorZ_is_ok(o: bigint): boolean {
23176 if(!isWasmInitialized) {
23177 throw new Error("initializeWasm() must be awaited first!");
23179 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
23180 return nativeResponseValue;
23182 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
23184 export function CResult_OutPointDecodeErrorZ_free(_res: bigint): void {
23185 if(!isWasmInitialized) {
23186 throw new Error("initializeWasm() must be awaited first!");
23188 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
23189 // debug statements here
23191 // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
23193 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23194 if(!isWasmInitialized) {
23195 throw new Error("initializeWasm() must be awaited first!");
23197 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
23198 return nativeResponseValue;
23200 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
23202 export function CResult_OutPointDecodeErrorZ_clone(orig: bigint): bigint {
23203 if(!isWasmInitialized) {
23204 throw new Error("initializeWasm() must be awaited first!");
23206 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
23207 return nativeResponseValue;
23209 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_ok(struct LDKBigSize o);
23211 export function CResult_BigSizeDecodeErrorZ_ok(o: bigint): bigint {
23212 if(!isWasmInitialized) {
23213 throw new Error("initializeWasm() must be awaited first!");
23215 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_ok(o);
23216 return nativeResponseValue;
23218 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_err(struct LDKDecodeError e);
23220 export function CResult_BigSizeDecodeErrorZ_err(e: bigint): bigint {
23221 if(!isWasmInitialized) {
23222 throw new Error("initializeWasm() must be awaited first!");
23224 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_err(e);
23225 return nativeResponseValue;
23227 // bool CResult_BigSizeDecodeErrorZ_is_ok(const struct LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR o);
23229 export function CResult_BigSizeDecodeErrorZ_is_ok(o: bigint): boolean {
23230 if(!isWasmInitialized) {
23231 throw new Error("initializeWasm() must be awaited first!");
23233 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_is_ok(o);
23234 return nativeResponseValue;
23236 // void CResult_BigSizeDecodeErrorZ_free(struct LDKCResult_BigSizeDecodeErrorZ _res);
23238 export function CResult_BigSizeDecodeErrorZ_free(_res: bigint): void {
23239 if(!isWasmInitialized) {
23240 throw new Error("initializeWasm() must be awaited first!");
23242 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_free(_res);
23243 // debug statements here
23245 // uint64_t CResult_BigSizeDecodeErrorZ_clone_ptr(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR arg);
23247 export function CResult_BigSizeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23248 if(!isWasmInitialized) {
23249 throw new Error("initializeWasm() must be awaited first!");
23251 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_clone_ptr(arg);
23252 return nativeResponseValue;
23254 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_clone(const struct LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR orig);
23256 export function CResult_BigSizeDecodeErrorZ_clone(orig: bigint): bigint {
23257 if(!isWasmInitialized) {
23258 throw new Error("initializeWasm() must be awaited first!");
23260 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_clone(orig);
23261 return nativeResponseValue;
23263 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_ok(struct LDKHostname o);
23265 export function CResult_HostnameDecodeErrorZ_ok(o: bigint): bigint {
23266 if(!isWasmInitialized) {
23267 throw new Error("initializeWasm() must be awaited first!");
23269 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_ok(o);
23270 return nativeResponseValue;
23272 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_err(struct LDKDecodeError e);
23274 export function CResult_HostnameDecodeErrorZ_err(e: bigint): bigint {
23275 if(!isWasmInitialized) {
23276 throw new Error("initializeWasm() must be awaited first!");
23278 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_err(e);
23279 return nativeResponseValue;
23281 // bool CResult_HostnameDecodeErrorZ_is_ok(const struct LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR o);
23283 export function CResult_HostnameDecodeErrorZ_is_ok(o: bigint): boolean {
23284 if(!isWasmInitialized) {
23285 throw new Error("initializeWasm() must be awaited first!");
23287 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_is_ok(o);
23288 return nativeResponseValue;
23290 // void CResult_HostnameDecodeErrorZ_free(struct LDKCResult_HostnameDecodeErrorZ _res);
23292 export function CResult_HostnameDecodeErrorZ_free(_res: bigint): void {
23293 if(!isWasmInitialized) {
23294 throw new Error("initializeWasm() must be awaited first!");
23296 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_free(_res);
23297 // debug statements here
23299 // uint64_t CResult_HostnameDecodeErrorZ_clone_ptr(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR arg);
23301 export function CResult_HostnameDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23302 if(!isWasmInitialized) {
23303 throw new Error("initializeWasm() must be awaited first!");
23305 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_clone_ptr(arg);
23306 return nativeResponseValue;
23308 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_clone(const struct LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR orig);
23310 export function CResult_HostnameDecodeErrorZ_clone(orig: bigint): bigint {
23311 if(!isWasmInitialized) {
23312 throw new Error("initializeWasm() must be awaited first!");
23314 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_clone(orig);
23315 return nativeResponseValue;
23317 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_ok(struct LDKTransactionU16LenLimited o);
23319 export function CResult_TransactionU16LenLimitedNoneZ_ok(o: bigint): bigint {
23320 if(!isWasmInitialized) {
23321 throw new Error("initializeWasm() must be awaited first!");
23323 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_ok(o);
23324 return nativeResponseValue;
23326 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_err(void);
23328 export function CResult_TransactionU16LenLimitedNoneZ_err(): bigint {
23329 if(!isWasmInitialized) {
23330 throw new Error("initializeWasm() must be awaited first!");
23332 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_err();
23333 return nativeResponseValue;
23335 // bool CResult_TransactionU16LenLimitedNoneZ_is_ok(const struct LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR o);
23337 export function CResult_TransactionU16LenLimitedNoneZ_is_ok(o: bigint): boolean {
23338 if(!isWasmInitialized) {
23339 throw new Error("initializeWasm() must be awaited first!");
23341 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_is_ok(o);
23342 return nativeResponseValue;
23344 // void CResult_TransactionU16LenLimitedNoneZ_free(struct LDKCResult_TransactionU16LenLimitedNoneZ _res);
23346 export function CResult_TransactionU16LenLimitedNoneZ_free(_res: bigint): void {
23347 if(!isWasmInitialized) {
23348 throw new Error("initializeWasm() must be awaited first!");
23350 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_free(_res);
23351 // debug statements here
23353 // uint64_t CResult_TransactionU16LenLimitedNoneZ_clone_ptr(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR arg);
23355 export function CResult_TransactionU16LenLimitedNoneZ_clone_ptr(arg: bigint): bigint {
23356 if(!isWasmInitialized) {
23357 throw new Error("initializeWasm() must be awaited first!");
23359 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_clone_ptr(arg);
23360 return nativeResponseValue;
23362 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_clone(const struct LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR orig);
23364 export function CResult_TransactionU16LenLimitedNoneZ_clone(orig: bigint): bigint {
23365 if(!isWasmInitialized) {
23366 throw new Error("initializeWasm() must be awaited first!");
23368 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_clone(orig);
23369 return nativeResponseValue;
23371 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_ok(struct LDKTransactionU16LenLimited o);
23373 export function CResult_TransactionU16LenLimitedDecodeErrorZ_ok(o: bigint): bigint {
23374 if(!isWasmInitialized) {
23375 throw new Error("initializeWasm() must be awaited first!");
23377 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_ok(o);
23378 return nativeResponseValue;
23380 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_err(struct LDKDecodeError e);
23382 export function CResult_TransactionU16LenLimitedDecodeErrorZ_err(e: bigint): bigint {
23383 if(!isWasmInitialized) {
23384 throw new Error("initializeWasm() must be awaited first!");
23386 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_err(e);
23387 return nativeResponseValue;
23389 // bool CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(const struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR o);
23391 export function CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(o: bigint): boolean {
23392 if(!isWasmInitialized) {
23393 throw new Error("initializeWasm() must be awaited first!");
23395 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(o);
23396 return nativeResponseValue;
23398 // void CResult_TransactionU16LenLimitedDecodeErrorZ_free(struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ _res);
23400 export function CResult_TransactionU16LenLimitedDecodeErrorZ_free(_res: bigint): void {
23401 if(!isWasmInitialized) {
23402 throw new Error("initializeWasm() must be awaited first!");
23404 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_free(_res);
23405 // debug statements here
23407 // uint64_t CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR arg);
23409 export function CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23410 if(!isWasmInitialized) {
23411 throw new Error("initializeWasm() must be awaited first!");
23413 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(arg);
23414 return nativeResponseValue;
23416 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_clone(const struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR orig);
23418 export function CResult_TransactionU16LenLimitedDecodeErrorZ_clone(orig: bigint): bigint {
23419 if(!isWasmInitialized) {
23420 throw new Error("initializeWasm() must be awaited first!");
23422 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone(orig);
23423 return nativeResponseValue;
23425 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_ok(struct LDKUntrustedString o);
23427 export function CResult_UntrustedStringDecodeErrorZ_ok(o: bigint): bigint {
23428 if(!isWasmInitialized) {
23429 throw new Error("initializeWasm() must be awaited first!");
23431 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_ok(o);
23432 return nativeResponseValue;
23434 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_err(struct LDKDecodeError e);
23436 export function CResult_UntrustedStringDecodeErrorZ_err(e: bigint): bigint {
23437 if(!isWasmInitialized) {
23438 throw new Error("initializeWasm() must be awaited first!");
23440 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_err(e);
23441 return nativeResponseValue;
23443 // bool CResult_UntrustedStringDecodeErrorZ_is_ok(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR o);
23445 export function CResult_UntrustedStringDecodeErrorZ_is_ok(o: bigint): boolean {
23446 if(!isWasmInitialized) {
23447 throw new Error("initializeWasm() must be awaited first!");
23449 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_is_ok(o);
23450 return nativeResponseValue;
23452 // void CResult_UntrustedStringDecodeErrorZ_free(struct LDKCResult_UntrustedStringDecodeErrorZ _res);
23454 export function CResult_UntrustedStringDecodeErrorZ_free(_res: bigint): void {
23455 if(!isWasmInitialized) {
23456 throw new Error("initializeWasm() must be awaited first!");
23458 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_free(_res);
23459 // debug statements here
23461 // uint64_t CResult_UntrustedStringDecodeErrorZ_clone_ptr(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR arg);
23463 export function CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23464 if(!isWasmInitialized) {
23465 throw new Error("initializeWasm() must be awaited first!");
23467 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg);
23468 return nativeResponseValue;
23470 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_clone(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR orig);
23472 export function CResult_UntrustedStringDecodeErrorZ_clone(orig: bigint): bigint {
23473 if(!isWasmInitialized) {
23474 throw new Error("initializeWasm() must be awaited first!");
23476 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone(orig);
23477 return nativeResponseValue;
23479 // struct LDKCResult_ReceiveTlvsDecodeErrorZ CResult_ReceiveTlvsDecodeErrorZ_ok(struct LDKReceiveTlvs o);
23481 export function CResult_ReceiveTlvsDecodeErrorZ_ok(o: bigint): bigint {
23482 if(!isWasmInitialized) {
23483 throw new Error("initializeWasm() must be awaited first!");
23485 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_ok(o);
23486 return nativeResponseValue;
23488 // struct LDKCResult_ReceiveTlvsDecodeErrorZ CResult_ReceiveTlvsDecodeErrorZ_err(struct LDKDecodeError e);
23490 export function CResult_ReceiveTlvsDecodeErrorZ_err(e: bigint): bigint {
23491 if(!isWasmInitialized) {
23492 throw new Error("initializeWasm() must be awaited first!");
23494 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_err(e);
23495 return nativeResponseValue;
23497 // bool CResult_ReceiveTlvsDecodeErrorZ_is_ok(const struct LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR o);
23499 export function CResult_ReceiveTlvsDecodeErrorZ_is_ok(o: bigint): boolean {
23500 if(!isWasmInitialized) {
23501 throw new Error("initializeWasm() must be awaited first!");
23503 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_is_ok(o);
23504 return nativeResponseValue;
23506 // void CResult_ReceiveTlvsDecodeErrorZ_free(struct LDKCResult_ReceiveTlvsDecodeErrorZ _res);
23508 export function CResult_ReceiveTlvsDecodeErrorZ_free(_res: bigint): void {
23509 if(!isWasmInitialized) {
23510 throw new Error("initializeWasm() must be awaited first!");
23512 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_free(_res);
23513 // debug statements here
23515 // uint64_t CResult_ReceiveTlvsDecodeErrorZ_clone_ptr(LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR arg);
23517 export function CResult_ReceiveTlvsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23518 if(!isWasmInitialized) {
23519 throw new Error("initializeWasm() must be awaited first!");
23521 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_clone_ptr(arg);
23522 return nativeResponseValue;
23524 // struct LDKCResult_ReceiveTlvsDecodeErrorZ CResult_ReceiveTlvsDecodeErrorZ_clone(const struct LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR orig);
23526 export function CResult_ReceiveTlvsDecodeErrorZ_clone(orig: bigint): bigint {
23527 if(!isWasmInitialized) {
23528 throw new Error("initializeWasm() must be awaited first!");
23530 const nativeResponseValue = wasm.TS_CResult_ReceiveTlvsDecodeErrorZ_clone(orig);
23531 return nativeResponseValue;
23533 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_ok(struct LDKPaymentRelay o);
23535 export function CResult_PaymentRelayDecodeErrorZ_ok(o: bigint): bigint {
23536 if(!isWasmInitialized) {
23537 throw new Error("initializeWasm() must be awaited first!");
23539 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_ok(o);
23540 return nativeResponseValue;
23542 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_err(struct LDKDecodeError e);
23544 export function CResult_PaymentRelayDecodeErrorZ_err(e: bigint): bigint {
23545 if(!isWasmInitialized) {
23546 throw new Error("initializeWasm() must be awaited first!");
23548 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_err(e);
23549 return nativeResponseValue;
23551 // bool CResult_PaymentRelayDecodeErrorZ_is_ok(const struct LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR o);
23553 export function CResult_PaymentRelayDecodeErrorZ_is_ok(o: bigint): boolean {
23554 if(!isWasmInitialized) {
23555 throw new Error("initializeWasm() must be awaited first!");
23557 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_is_ok(o);
23558 return nativeResponseValue;
23560 // void CResult_PaymentRelayDecodeErrorZ_free(struct LDKCResult_PaymentRelayDecodeErrorZ _res);
23562 export function CResult_PaymentRelayDecodeErrorZ_free(_res: bigint): void {
23563 if(!isWasmInitialized) {
23564 throw new Error("initializeWasm() must be awaited first!");
23566 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_free(_res);
23567 // debug statements here
23569 // uint64_t CResult_PaymentRelayDecodeErrorZ_clone_ptr(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR arg);
23571 export function CResult_PaymentRelayDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23572 if(!isWasmInitialized) {
23573 throw new Error("initializeWasm() must be awaited first!");
23575 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_clone_ptr(arg);
23576 return nativeResponseValue;
23578 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_clone(const struct LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR orig);
23580 export function CResult_PaymentRelayDecodeErrorZ_clone(orig: bigint): bigint {
23581 if(!isWasmInitialized) {
23582 throw new Error("initializeWasm() must be awaited first!");
23584 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_clone(orig);
23585 return nativeResponseValue;
23587 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_ok(struct LDKPaymentConstraints o);
23589 export function CResult_PaymentConstraintsDecodeErrorZ_ok(o: bigint): bigint {
23590 if(!isWasmInitialized) {
23591 throw new Error("initializeWasm() must be awaited first!");
23593 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_ok(o);
23594 return nativeResponseValue;
23596 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_err(struct LDKDecodeError e);
23598 export function CResult_PaymentConstraintsDecodeErrorZ_err(e: bigint): bigint {
23599 if(!isWasmInitialized) {
23600 throw new Error("initializeWasm() must be awaited first!");
23602 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_err(e);
23603 return nativeResponseValue;
23605 // bool CResult_PaymentConstraintsDecodeErrorZ_is_ok(const struct LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR o);
23607 export function CResult_PaymentConstraintsDecodeErrorZ_is_ok(o: bigint): boolean {
23608 if(!isWasmInitialized) {
23609 throw new Error("initializeWasm() must be awaited first!");
23611 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_is_ok(o);
23612 return nativeResponseValue;
23614 // void CResult_PaymentConstraintsDecodeErrorZ_free(struct LDKCResult_PaymentConstraintsDecodeErrorZ _res);
23616 export function CResult_PaymentConstraintsDecodeErrorZ_free(_res: bigint): void {
23617 if(!isWasmInitialized) {
23618 throw new Error("initializeWasm() must be awaited first!");
23620 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_free(_res);
23621 // debug statements here
23623 // uint64_t CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR arg);
23625 export function CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23626 if(!isWasmInitialized) {
23627 throw new Error("initializeWasm() must be awaited first!");
23629 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(arg);
23630 return nativeResponseValue;
23632 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_clone(const struct LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR orig);
23634 export function CResult_PaymentConstraintsDecodeErrorZ_clone(orig: bigint): bigint {
23635 if(!isWasmInitialized) {
23636 throw new Error("initializeWasm() must be awaited first!");
23638 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_clone(orig);
23639 return nativeResponseValue;
23641 // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ CResult_ThirtyTwoBytesPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
23643 export function CResult_ThirtyTwoBytesPaymentErrorZ_ok(o: number): bigint {
23644 if(!isWasmInitialized) {
23645 throw new Error("initializeWasm() must be awaited first!");
23647 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_ok(o);
23648 return nativeResponseValue;
23650 // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ CResult_ThirtyTwoBytesPaymentErrorZ_err(struct LDKPaymentError e);
23652 export function CResult_ThirtyTwoBytesPaymentErrorZ_err(e: bigint): bigint {
23653 if(!isWasmInitialized) {
23654 throw new Error("initializeWasm() must be awaited first!");
23656 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_err(e);
23657 return nativeResponseValue;
23659 // bool CResult_ThirtyTwoBytesPaymentErrorZ_is_ok(const struct LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR o);
23661 export function CResult_ThirtyTwoBytesPaymentErrorZ_is_ok(o: bigint): boolean {
23662 if(!isWasmInitialized) {
23663 throw new Error("initializeWasm() must be awaited first!");
23665 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_is_ok(o);
23666 return nativeResponseValue;
23668 // void CResult_ThirtyTwoBytesPaymentErrorZ_free(struct LDKCResult_ThirtyTwoBytesPaymentErrorZ _res);
23670 export function CResult_ThirtyTwoBytesPaymentErrorZ_free(_res: bigint): void {
23671 if(!isWasmInitialized) {
23672 throw new Error("initializeWasm() must be awaited first!");
23674 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_free(_res);
23675 // debug statements here
23677 // uint64_t CResult_ThirtyTwoBytesPaymentErrorZ_clone_ptr(LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR arg);
23679 export function CResult_ThirtyTwoBytesPaymentErrorZ_clone_ptr(arg: bigint): bigint {
23680 if(!isWasmInitialized) {
23681 throw new Error("initializeWasm() must be awaited first!");
23683 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_clone_ptr(arg);
23684 return nativeResponseValue;
23686 // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ CResult_ThirtyTwoBytesPaymentErrorZ_clone(const struct LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR orig);
23688 export function CResult_ThirtyTwoBytesPaymentErrorZ_clone(orig: bigint): bigint {
23689 if(!isWasmInitialized) {
23690 throw new Error("initializeWasm() must be awaited first!");
23692 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentErrorZ_clone(orig);
23693 return nativeResponseValue;
23695 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_ok(void);
23697 export function CResult_NonePaymentErrorZ_ok(): bigint {
23698 if(!isWasmInitialized) {
23699 throw new Error("initializeWasm() must be awaited first!");
23701 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_ok();
23702 return nativeResponseValue;
23704 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_err(struct LDKPaymentError e);
23706 export function CResult_NonePaymentErrorZ_err(e: bigint): bigint {
23707 if(!isWasmInitialized) {
23708 throw new Error("initializeWasm() must be awaited first!");
23710 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_err(e);
23711 return nativeResponseValue;
23713 // bool CResult_NonePaymentErrorZ_is_ok(const struct LDKCResult_NonePaymentErrorZ *NONNULL_PTR o);
23715 export function CResult_NonePaymentErrorZ_is_ok(o: bigint): boolean {
23716 if(!isWasmInitialized) {
23717 throw new Error("initializeWasm() must be awaited first!");
23719 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_is_ok(o);
23720 return nativeResponseValue;
23722 // void CResult_NonePaymentErrorZ_free(struct LDKCResult_NonePaymentErrorZ _res);
23724 export function CResult_NonePaymentErrorZ_free(_res: bigint): void {
23725 if(!isWasmInitialized) {
23726 throw new Error("initializeWasm() must be awaited first!");
23728 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_free(_res);
23729 // debug statements here
23731 // uint64_t CResult_NonePaymentErrorZ_clone_ptr(LDKCResult_NonePaymentErrorZ *NONNULL_PTR arg);
23733 export function CResult_NonePaymentErrorZ_clone_ptr(arg: bigint): bigint {
23734 if(!isWasmInitialized) {
23735 throw new Error("initializeWasm() must be awaited first!");
23737 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_clone_ptr(arg);
23738 return nativeResponseValue;
23740 // struct LDKCResult_NonePaymentErrorZ CResult_NonePaymentErrorZ_clone(const struct LDKCResult_NonePaymentErrorZ *NONNULL_PTR orig);
23742 export function CResult_NonePaymentErrorZ_clone(orig: bigint): bigint {
23743 if(!isWasmInitialized) {
23744 throw new Error("initializeWasm() must be awaited first!");
23746 const nativeResponseValue = wasm.TS_CResult_NonePaymentErrorZ_clone(orig);
23747 return nativeResponseValue;
23749 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_ok(struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ o);
23751 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_ok(o: number): bigint {
23752 if(!isWasmInitialized) {
23753 throw new Error("initializeWasm() must be awaited first!");
23755 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_ok(o);
23756 return nativeResponseValue;
23758 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_err(struct LDKProbingError e);
23760 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_err(e: bigint): bigint {
23761 if(!isWasmInitialized) {
23762 throw new Error("initializeWasm() must be awaited first!");
23764 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_err(e);
23765 return nativeResponseValue;
23767 // bool CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_is_ok(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR o);
23769 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_is_ok(o: bigint): boolean {
23770 if(!isWasmInitialized) {
23771 throw new Error("initializeWasm() must be awaited first!");
23773 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_is_ok(o);
23774 return nativeResponseValue;
23776 // void CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ _res);
23778 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(_res: bigint): void {
23779 if(!isWasmInitialized) {
23780 throw new Error("initializeWasm() must be awaited first!");
23782 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(_res);
23783 // debug statements here
23785 // uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR arg);
23787 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone_ptr(arg: bigint): bigint {
23788 if(!isWasmInitialized) {
23789 throw new Error("initializeWasm() must be awaited first!");
23791 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone_ptr(arg);
23792 return nativeResponseValue;
23794 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR orig);
23796 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone(orig: bigint): bigint {
23797 if(!isWasmInitialized) {
23798 throw new Error("initializeWasm() must be awaited first!");
23800 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone(orig);
23801 return nativeResponseValue;
23803 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_ok(struct LDKStr o);
23805 export function CResult_StrSecp256k1ErrorZ_ok(o: number): bigint {
23806 if(!isWasmInitialized) {
23807 throw new Error("initializeWasm() must be awaited first!");
23809 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_ok(o);
23810 return nativeResponseValue;
23812 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
23814 export function CResult_StrSecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
23815 if(!isWasmInitialized) {
23816 throw new Error("initializeWasm() must be awaited first!");
23818 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_err(e);
23819 return nativeResponseValue;
23821 // bool CResult_StrSecp256k1ErrorZ_is_ok(const struct LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR o);
23823 export function CResult_StrSecp256k1ErrorZ_is_ok(o: bigint): boolean {
23824 if(!isWasmInitialized) {
23825 throw new Error("initializeWasm() must be awaited first!");
23827 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_is_ok(o);
23828 return nativeResponseValue;
23830 // void CResult_StrSecp256k1ErrorZ_free(struct LDKCResult_StrSecp256k1ErrorZ _res);
23832 export function CResult_StrSecp256k1ErrorZ_free(_res: bigint): void {
23833 if(!isWasmInitialized) {
23834 throw new Error("initializeWasm() must be awaited first!");
23836 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_free(_res);
23837 // debug statements here
23839 // uint64_t CResult_StrSecp256k1ErrorZ_clone_ptr(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR arg);
23841 export function CResult_StrSecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
23842 if(!isWasmInitialized) {
23843 throw new Error("initializeWasm() must be awaited first!");
23845 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_clone_ptr(arg);
23846 return nativeResponseValue;
23848 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_clone(const struct LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR orig);
23850 export function CResult_StrSecp256k1ErrorZ_clone(orig: bigint): bigint {
23851 if(!isWasmInitialized) {
23852 throw new Error("initializeWasm() must be awaited first!");
23854 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_clone(orig);
23855 return nativeResponseValue;
23857 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_ok(struct LDKTxOut o);
23859 export function CResult_TxOutUtxoLookupErrorZ_ok(o: bigint): bigint {
23860 if(!isWasmInitialized) {
23861 throw new Error("initializeWasm() must be awaited first!");
23863 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_ok(o);
23864 return nativeResponseValue;
23866 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_err(enum LDKUtxoLookupError e);
23868 export function CResult_TxOutUtxoLookupErrorZ_err(e: UtxoLookupError): bigint {
23869 if(!isWasmInitialized) {
23870 throw new Error("initializeWasm() must be awaited first!");
23872 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_err(e);
23873 return nativeResponseValue;
23875 // bool CResult_TxOutUtxoLookupErrorZ_is_ok(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR o);
23877 export function CResult_TxOutUtxoLookupErrorZ_is_ok(o: bigint): boolean {
23878 if(!isWasmInitialized) {
23879 throw new Error("initializeWasm() must be awaited first!");
23881 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_is_ok(o);
23882 return nativeResponseValue;
23884 // void CResult_TxOutUtxoLookupErrorZ_free(struct LDKCResult_TxOutUtxoLookupErrorZ _res);
23886 export function CResult_TxOutUtxoLookupErrorZ_free(_res: bigint): void {
23887 if(!isWasmInitialized) {
23888 throw new Error("initializeWasm() must be awaited first!");
23890 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_free(_res);
23891 // debug statements here
23893 // uint64_t CResult_TxOutUtxoLookupErrorZ_clone_ptr(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR arg);
23895 export function CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg: bigint): bigint {
23896 if(!isWasmInitialized) {
23897 throw new Error("initializeWasm() must be awaited first!");
23899 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg);
23900 return nativeResponseValue;
23902 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_clone(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR orig);
23904 export function CResult_TxOutUtxoLookupErrorZ_clone(orig: bigint): bigint {
23905 if(!isWasmInitialized) {
23906 throw new Error("initializeWasm() must be awaited first!");
23908 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone(orig);
23909 return nativeResponseValue;
23911 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_ok(struct LDKOnionMessagePath o);
23913 export function CResult_OnionMessagePathNoneZ_ok(o: bigint): bigint {
23914 if(!isWasmInitialized) {
23915 throw new Error("initializeWasm() must be awaited first!");
23917 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_ok(o);
23918 return nativeResponseValue;
23920 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_err(void);
23922 export function CResult_OnionMessagePathNoneZ_err(): bigint {
23923 if(!isWasmInitialized) {
23924 throw new Error("initializeWasm() must be awaited first!");
23926 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_err();
23927 return nativeResponseValue;
23929 // bool CResult_OnionMessagePathNoneZ_is_ok(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR o);
23931 export function CResult_OnionMessagePathNoneZ_is_ok(o: bigint): boolean {
23932 if(!isWasmInitialized) {
23933 throw new Error("initializeWasm() must be awaited first!");
23935 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_is_ok(o);
23936 return nativeResponseValue;
23938 // void CResult_OnionMessagePathNoneZ_free(struct LDKCResult_OnionMessagePathNoneZ _res);
23940 export function CResult_OnionMessagePathNoneZ_free(_res: bigint): void {
23941 if(!isWasmInitialized) {
23942 throw new Error("initializeWasm() must be awaited first!");
23944 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_free(_res);
23945 // debug statements here
23947 // uint64_t CResult_OnionMessagePathNoneZ_clone_ptr(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR arg);
23949 export function CResult_OnionMessagePathNoneZ_clone_ptr(arg: bigint): bigint {
23950 if(!isWasmInitialized) {
23951 throw new Error("initializeWasm() must be awaited first!");
23953 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_clone_ptr(arg);
23954 return nativeResponseValue;
23956 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_clone(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR orig);
23958 export function CResult_OnionMessagePathNoneZ_clone(orig: bigint): bigint {
23959 if(!isWasmInitialized) {
23960 throw new Error("initializeWasm() must be awaited first!");
23962 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_clone(orig);
23963 return nativeResponseValue;
23965 // uint64_t C2Tuple_PublicKeyOnionMessageZ_clone_ptr(LDKC2Tuple_PublicKeyOnionMessageZ *NONNULL_PTR arg);
23967 export function C2Tuple_PublicKeyOnionMessageZ_clone_ptr(arg: bigint): bigint {
23968 if(!isWasmInitialized) {
23969 throw new Error("initializeWasm() must be awaited first!");
23971 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_clone_ptr(arg);
23972 return nativeResponseValue;
23974 // struct LDKC2Tuple_PublicKeyOnionMessageZ C2Tuple_PublicKeyOnionMessageZ_clone(const struct LDKC2Tuple_PublicKeyOnionMessageZ *NONNULL_PTR orig);
23976 export function C2Tuple_PublicKeyOnionMessageZ_clone(orig: bigint): bigint {
23977 if(!isWasmInitialized) {
23978 throw new Error("initializeWasm() must be awaited first!");
23980 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_clone(orig);
23981 return nativeResponseValue;
23983 // struct LDKC2Tuple_PublicKeyOnionMessageZ C2Tuple_PublicKeyOnionMessageZ_new(struct LDKPublicKey a, struct LDKOnionMessage b);
23985 export function C2Tuple_PublicKeyOnionMessageZ_new(a: number, b: bigint): bigint {
23986 if(!isWasmInitialized) {
23987 throw new Error("initializeWasm() must be awaited first!");
23989 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_new(a, b);
23990 return nativeResponseValue;
23992 // void C2Tuple_PublicKeyOnionMessageZ_free(struct LDKC2Tuple_PublicKeyOnionMessageZ _res);
23994 export function C2Tuple_PublicKeyOnionMessageZ_free(_res: bigint): void {
23995 if(!isWasmInitialized) {
23996 throw new Error("initializeWasm() must be awaited first!");
23998 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyOnionMessageZ_free(_res);
23999 // debug statements here
24001 // struct LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_ok(struct LDKC2Tuple_PublicKeyOnionMessageZ o);
24003 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_ok(o: bigint): bigint {
24004 if(!isWasmInitialized) {
24005 throw new Error("initializeWasm() must be awaited first!");
24007 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_ok(o);
24008 return nativeResponseValue;
24010 // struct LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_err(struct LDKSendError e);
24012 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_err(e: bigint): bigint {
24013 if(!isWasmInitialized) {
24014 throw new Error("initializeWasm() must be awaited first!");
24016 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_err(e);
24017 return nativeResponseValue;
24019 // bool CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_is_ok(const struct LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ *NONNULL_PTR o);
24021 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_is_ok(o: bigint): boolean {
24022 if(!isWasmInitialized) {
24023 throw new Error("initializeWasm() must be awaited first!");
24025 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_is_ok(o);
24026 return nativeResponseValue;
24028 // void CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(struct LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ _res);
24030 export function CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(_res: bigint): void {
24031 if(!isWasmInitialized) {
24032 throw new Error("initializeWasm() must be awaited first!");
24034 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(_res);
24035 // debug statements here
24037 // struct LDKCResult_PeeledOnionNoneZ CResult_PeeledOnionNoneZ_ok(struct LDKPeeledOnion o);
24039 export function CResult_PeeledOnionNoneZ_ok(o: bigint): bigint {
24040 if(!isWasmInitialized) {
24041 throw new Error("initializeWasm() must be awaited first!");
24043 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_ok(o);
24044 return nativeResponseValue;
24046 // struct LDKCResult_PeeledOnionNoneZ CResult_PeeledOnionNoneZ_err(void);
24048 export function CResult_PeeledOnionNoneZ_err(): bigint {
24049 if(!isWasmInitialized) {
24050 throw new Error("initializeWasm() must be awaited first!");
24052 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_err();
24053 return nativeResponseValue;
24055 // bool CResult_PeeledOnionNoneZ_is_ok(const struct LDKCResult_PeeledOnionNoneZ *NONNULL_PTR o);
24057 export function CResult_PeeledOnionNoneZ_is_ok(o: bigint): boolean {
24058 if(!isWasmInitialized) {
24059 throw new Error("initializeWasm() must be awaited first!");
24061 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_is_ok(o);
24062 return nativeResponseValue;
24064 // void CResult_PeeledOnionNoneZ_free(struct LDKCResult_PeeledOnionNoneZ _res);
24066 export function CResult_PeeledOnionNoneZ_free(_res: bigint): void {
24067 if(!isWasmInitialized) {
24068 throw new Error("initializeWasm() must be awaited first!");
24070 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_free(_res);
24071 // debug statements here
24073 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_ok(void);
24075 export function CResult_NoneSendErrorZ_ok(): bigint {
24076 if(!isWasmInitialized) {
24077 throw new Error("initializeWasm() must be awaited first!");
24079 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_ok();
24080 return nativeResponseValue;
24082 // struct LDKCResult_NoneSendErrorZ CResult_NoneSendErrorZ_err(struct LDKSendError e);
24084 export function CResult_NoneSendErrorZ_err(e: bigint): bigint {
24085 if(!isWasmInitialized) {
24086 throw new Error("initializeWasm() must be awaited first!");
24088 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_err(e);
24089 return nativeResponseValue;
24091 // bool CResult_NoneSendErrorZ_is_ok(const struct LDKCResult_NoneSendErrorZ *NONNULL_PTR o);
24093 export function CResult_NoneSendErrorZ_is_ok(o: bigint): boolean {
24094 if(!isWasmInitialized) {
24095 throw new Error("initializeWasm() must be awaited first!");
24097 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_is_ok(o);
24098 return nativeResponseValue;
24100 // void CResult_NoneSendErrorZ_free(struct LDKCResult_NoneSendErrorZ _res);
24102 export function CResult_NoneSendErrorZ_free(_res: bigint): void {
24103 if(!isWasmInitialized) {
24104 throw new Error("initializeWasm() must be awaited first!");
24106 const nativeResponseValue = wasm.TS_CResult_NoneSendErrorZ_free(_res);
24107 // debug statements here
24109 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_ok(struct LDKBlindedPath o);
24111 export function CResult_BlindedPathNoneZ_ok(o: bigint): bigint {
24112 if(!isWasmInitialized) {
24113 throw new Error("initializeWasm() must be awaited first!");
24115 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_ok(o);
24116 return nativeResponseValue;
24118 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_err(void);
24120 export function CResult_BlindedPathNoneZ_err(): bigint {
24121 if(!isWasmInitialized) {
24122 throw new Error("initializeWasm() must be awaited first!");
24124 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_err();
24125 return nativeResponseValue;
24127 // bool CResult_BlindedPathNoneZ_is_ok(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR o);
24129 export function CResult_BlindedPathNoneZ_is_ok(o: bigint): boolean {
24130 if(!isWasmInitialized) {
24131 throw new Error("initializeWasm() must be awaited first!");
24133 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_is_ok(o);
24134 return nativeResponseValue;
24136 // void CResult_BlindedPathNoneZ_free(struct LDKCResult_BlindedPathNoneZ _res);
24138 export function CResult_BlindedPathNoneZ_free(_res: bigint): void {
24139 if(!isWasmInitialized) {
24140 throw new Error("initializeWasm() must be awaited first!");
24142 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_free(_res);
24143 // debug statements here
24145 // uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg);
24147 export function CResult_BlindedPathNoneZ_clone_ptr(arg: bigint): bigint {
24148 if(!isWasmInitialized) {
24149 throw new Error("initializeWasm() must be awaited first!");
24151 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone_ptr(arg);
24152 return nativeResponseValue;
24154 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_clone(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR orig);
24156 export function CResult_BlindedPathNoneZ_clone(orig: bigint): bigint {
24157 if(!isWasmInitialized) {
24158 throw new Error("initializeWasm() must be awaited first!");
24160 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone(orig);
24161 return nativeResponseValue;
24163 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ o);
24165 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(o: bigint): bigint {
24166 if(!isWasmInitialized) {
24167 throw new Error("initializeWasm() must be awaited first!");
24169 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(o);
24170 return nativeResponseValue;
24172 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err(void);
24174 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err(): bigint {
24175 if(!isWasmInitialized) {
24176 throw new Error("initializeWasm() must be awaited first!");
24178 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err();
24179 return nativeResponseValue;
24181 // bool CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(const struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR o);
24183 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(o: bigint): boolean {
24184 if(!isWasmInitialized) {
24185 throw new Error("initializeWasm() must be awaited first!");
24187 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(o);
24188 return nativeResponseValue;
24190 // void CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ _res);
24192 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(_res: bigint): void {
24193 if(!isWasmInitialized) {
24194 throw new Error("initializeWasm() must be awaited first!");
24196 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(_res);
24197 // debug statements here
24199 // uint64_t CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR arg);
24201 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(arg: bigint): bigint {
24202 if(!isWasmInitialized) {
24203 throw new Error("initializeWasm() must be awaited first!");
24205 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(arg);
24206 return nativeResponseValue;
24208 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(const struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR orig);
24210 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(orig: bigint): bigint {
24211 if(!isWasmInitialized) {
24212 throw new Error("initializeWasm() must be awaited first!");
24214 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(orig);
24215 return nativeResponseValue;
24217 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_ok(struct LDKBlindedPath o);
24219 export function CResult_BlindedPathDecodeErrorZ_ok(o: bigint): bigint {
24220 if(!isWasmInitialized) {
24221 throw new Error("initializeWasm() must be awaited first!");
24223 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_ok(o);
24224 return nativeResponseValue;
24226 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_err(struct LDKDecodeError e);
24228 export function CResult_BlindedPathDecodeErrorZ_err(e: bigint): bigint {
24229 if(!isWasmInitialized) {
24230 throw new Error("initializeWasm() must be awaited first!");
24232 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_err(e);
24233 return nativeResponseValue;
24235 // bool CResult_BlindedPathDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR o);
24237 export function CResult_BlindedPathDecodeErrorZ_is_ok(o: bigint): boolean {
24238 if(!isWasmInitialized) {
24239 throw new Error("initializeWasm() must be awaited first!");
24241 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_is_ok(o);
24242 return nativeResponseValue;
24244 // void CResult_BlindedPathDecodeErrorZ_free(struct LDKCResult_BlindedPathDecodeErrorZ _res);
24246 export function CResult_BlindedPathDecodeErrorZ_free(_res: bigint): void {
24247 if(!isWasmInitialized) {
24248 throw new Error("initializeWasm() must be awaited first!");
24250 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_free(_res);
24251 // debug statements here
24253 // uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg);
24255 export function CResult_BlindedPathDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24256 if(!isWasmInitialized) {
24257 throw new Error("initializeWasm() must be awaited first!");
24259 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(arg);
24260 return nativeResponseValue;
24262 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_clone(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR orig);
24264 export function CResult_BlindedPathDecodeErrorZ_clone(orig: bigint): bigint {
24265 if(!isWasmInitialized) {
24266 throw new Error("initializeWasm() must be awaited first!");
24268 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone(orig);
24269 return nativeResponseValue;
24271 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_ok(struct LDKBlindedHop o);
24273 export function CResult_BlindedHopDecodeErrorZ_ok(o: bigint): bigint {
24274 if(!isWasmInitialized) {
24275 throw new Error("initializeWasm() must be awaited first!");
24277 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_ok(o);
24278 return nativeResponseValue;
24280 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_err(struct LDKDecodeError e);
24282 export function CResult_BlindedHopDecodeErrorZ_err(e: bigint): bigint {
24283 if(!isWasmInitialized) {
24284 throw new Error("initializeWasm() must be awaited first!");
24286 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_err(e);
24287 return nativeResponseValue;
24289 // bool CResult_BlindedHopDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR o);
24291 export function CResult_BlindedHopDecodeErrorZ_is_ok(o: bigint): boolean {
24292 if(!isWasmInitialized) {
24293 throw new Error("initializeWasm() must be awaited first!");
24295 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_is_ok(o);
24296 return nativeResponseValue;
24298 // void CResult_BlindedHopDecodeErrorZ_free(struct LDKCResult_BlindedHopDecodeErrorZ _res);
24300 export function CResult_BlindedHopDecodeErrorZ_free(_res: bigint): void {
24301 if(!isWasmInitialized) {
24302 throw new Error("initializeWasm() must be awaited first!");
24304 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_free(_res);
24305 // debug statements here
24307 // uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg);
24309 export function CResult_BlindedHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24310 if(!isWasmInitialized) {
24311 throw new Error("initializeWasm() must be awaited first!");
24313 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(arg);
24314 return nativeResponseValue;
24316 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_clone(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR orig);
24318 export function CResult_BlindedHopDecodeErrorZ_clone(orig: bigint): bigint {
24319 if(!isWasmInitialized) {
24320 throw new Error("initializeWasm() must be awaited first!");
24322 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone(orig);
24323 return nativeResponseValue;
24325 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_ok(struct LDKInvoiceError o);
24327 export function CResult_InvoiceErrorDecodeErrorZ_ok(o: bigint): bigint {
24328 if(!isWasmInitialized) {
24329 throw new Error("initializeWasm() must be awaited first!");
24331 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_ok(o);
24332 return nativeResponseValue;
24334 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_err(struct LDKDecodeError e);
24336 export function CResult_InvoiceErrorDecodeErrorZ_err(e: bigint): bigint {
24337 if(!isWasmInitialized) {
24338 throw new Error("initializeWasm() must be awaited first!");
24340 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_err(e);
24341 return nativeResponseValue;
24343 // bool CResult_InvoiceErrorDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR o);
24345 export function CResult_InvoiceErrorDecodeErrorZ_is_ok(o: bigint): boolean {
24346 if(!isWasmInitialized) {
24347 throw new Error("initializeWasm() must be awaited first!");
24349 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_is_ok(o);
24350 return nativeResponseValue;
24352 // void CResult_InvoiceErrorDecodeErrorZ_free(struct LDKCResult_InvoiceErrorDecodeErrorZ _res);
24354 export function CResult_InvoiceErrorDecodeErrorZ_free(_res: bigint): void {
24355 if(!isWasmInitialized) {
24356 throw new Error("initializeWasm() must be awaited first!");
24358 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_free(_res);
24359 // debug statements here
24361 // uint64_t CResult_InvoiceErrorDecodeErrorZ_clone_ptr(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR arg);
24363 export function CResult_InvoiceErrorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24364 if(!isWasmInitialized) {
24365 throw new Error("initializeWasm() must be awaited first!");
24367 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_clone_ptr(arg);
24368 return nativeResponseValue;
24370 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_clone(const struct LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR orig);
24372 export function CResult_InvoiceErrorDecodeErrorZ_clone(orig: bigint): bigint {
24373 if(!isWasmInitialized) {
24374 throw new Error("initializeWasm() must be awaited first!");
24376 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_clone(orig);
24377 return nativeResponseValue;
24379 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
24381 export function COption_FilterZ_some(o: bigint): bigint {
24382 if(!isWasmInitialized) {
24383 throw new Error("initializeWasm() must be awaited first!");
24385 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
24386 return nativeResponseValue;
24388 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
24390 export function COption_FilterZ_none(): bigint {
24391 if(!isWasmInitialized) {
24392 throw new Error("initializeWasm() must be awaited first!");
24394 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
24395 return nativeResponseValue;
24397 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
24399 export function COption_FilterZ_free(_res: bigint): void {
24400 if(!isWasmInitialized) {
24401 throw new Error("initializeWasm() must be awaited first!");
24403 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
24404 // debug statements here
24406 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
24408 export function CResult_LockedChannelMonitorNoneZ_ok(o: bigint): bigint {
24409 if(!isWasmInitialized) {
24410 throw new Error("initializeWasm() must be awaited first!");
24412 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
24413 return nativeResponseValue;
24415 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
24417 export function CResult_LockedChannelMonitorNoneZ_err(): bigint {
24418 if(!isWasmInitialized) {
24419 throw new Error("initializeWasm() must be awaited first!");
24421 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
24422 return nativeResponseValue;
24424 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
24426 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: bigint): boolean {
24427 if(!isWasmInitialized) {
24428 throw new Error("initializeWasm() must be awaited first!");
24430 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
24431 return nativeResponseValue;
24433 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
24435 export function CResult_LockedChannelMonitorNoneZ_free(_res: bigint): void {
24436 if(!isWasmInitialized) {
24437 throw new Error("initializeWasm() must be awaited first!");
24439 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
24440 // debug statements here
24442 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
24444 export function CVec_OutPointZ_free(_res: number): void {
24445 if(!isWasmInitialized) {
24446 throw new Error("initializeWasm() must be awaited first!");
24448 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
24449 // debug statements here
24451 // void CVec_MonitorUpdateIdZ_free(struct LDKCVec_MonitorUpdateIdZ _res);
24453 export function CVec_MonitorUpdateIdZ_free(_res: number): void {
24454 if(!isWasmInitialized) {
24455 throw new Error("initializeWasm() must be awaited first!");
24457 const nativeResponseValue = wasm.TS_CVec_MonitorUpdateIdZ_free(_res);
24458 // debug statements here
24460 // uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg);
24462 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg: bigint): bigint {
24463 if(!isWasmInitialized) {
24464 throw new Error("initializeWasm() must be awaited first!");
24466 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg);
24467 return nativeResponseValue;
24469 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR orig);
24471 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig: bigint): bigint {
24472 if(!isWasmInitialized) {
24473 throw new Error("initializeWasm() must be awaited first!");
24475 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig);
24476 return nativeResponseValue;
24478 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorUpdateIdZ b);
24480 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a: bigint, b: number): bigint {
24481 if(!isWasmInitialized) {
24482 throw new Error("initializeWasm() must be awaited first!");
24484 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a, b);
24485 return nativeResponseValue;
24487 // void C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res);
24489 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res: bigint): void {
24490 if(!isWasmInitialized) {
24491 throw new Error("initializeWasm() must be awaited first!");
24493 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res);
24494 // debug statements here
24496 // void CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res);
24498 export function CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res: number): void {
24499 if(!isWasmInitialized) {
24500 throw new Error("initializeWasm() must be awaited first!");
24502 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res);
24503 // debug statements here
24505 // void APIError_free(struct LDKAPIError this_ptr);
24507 export function APIError_free(this_ptr: bigint): void {
24508 if(!isWasmInitialized) {
24509 throw new Error("initializeWasm() must be awaited first!");
24511 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
24512 // debug statements here
24514 // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
24516 export function APIError_clone_ptr(arg: bigint): bigint {
24517 if(!isWasmInitialized) {
24518 throw new Error("initializeWasm() must be awaited first!");
24520 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
24521 return nativeResponseValue;
24523 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
24525 export function APIError_clone(orig: bigint): bigint {
24526 if(!isWasmInitialized) {
24527 throw new Error("initializeWasm() must be awaited first!");
24529 const nativeResponseValue = wasm.TS_APIError_clone(orig);
24530 return nativeResponseValue;
24532 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
24534 export function APIError_apimisuse_error(err: number): bigint {
24535 if(!isWasmInitialized) {
24536 throw new Error("initializeWasm() must be awaited first!");
24538 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
24539 return nativeResponseValue;
24541 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
24543 export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
24544 if(!isWasmInitialized) {
24545 throw new Error("initializeWasm() must be awaited first!");
24547 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
24548 return nativeResponseValue;
24550 // struct LDKAPIError APIError_invalid_route(struct LDKStr err);
24552 export function APIError_invalid_route(err: number): bigint {
24553 if(!isWasmInitialized) {
24554 throw new Error("initializeWasm() must be awaited first!");
24556 const nativeResponseValue = wasm.TS_APIError_invalid_route(err);
24557 return nativeResponseValue;
24559 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
24561 export function APIError_channel_unavailable(err: number): bigint {
24562 if(!isWasmInitialized) {
24563 throw new Error("initializeWasm() must be awaited first!");
24565 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
24566 return nativeResponseValue;
24568 // struct LDKAPIError APIError_monitor_update_in_progress(void);
24570 export function APIError_monitor_update_in_progress(): bigint {
24571 if(!isWasmInitialized) {
24572 throw new Error("initializeWasm() must be awaited first!");
24574 const nativeResponseValue = wasm.TS_APIError_monitor_update_in_progress();
24575 return nativeResponseValue;
24577 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
24579 export function APIError_incompatible_shutdown_script(script: bigint): bigint {
24580 if(!isWasmInitialized) {
24581 throw new Error("initializeWasm() must be awaited first!");
24583 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
24584 return nativeResponseValue;
24586 // bool APIError_eq(const struct LDKAPIError *NONNULL_PTR a, const struct LDKAPIError *NONNULL_PTR b);
24588 export function APIError_eq(a: bigint, b: bigint): boolean {
24589 if(!isWasmInitialized) {
24590 throw new Error("initializeWasm() must be awaited first!");
24592 const nativeResponseValue = wasm.TS_APIError_eq(a, b);
24593 return nativeResponseValue;
24595 // struct LDKCVec_u8Z APIError_write(const struct LDKAPIError *NONNULL_PTR obj);
24597 export function APIError_write(obj: bigint): number {
24598 if(!isWasmInitialized) {
24599 throw new Error("initializeWasm() must be awaited first!");
24601 const nativeResponseValue = wasm.TS_APIError_write(obj);
24602 return nativeResponseValue;
24604 // struct LDKCResult_COption_APIErrorZDecodeErrorZ APIError_read(struct LDKu8slice ser);
24606 export function APIError_read(ser: number): bigint {
24607 if(!isWasmInitialized) {
24608 throw new Error("initializeWasm() must be awaited first!");
24610 const nativeResponseValue = wasm.TS_APIError_read(ser);
24611 return nativeResponseValue;
24613 // void BigSize_free(struct LDKBigSize this_obj);
24615 export function BigSize_free(this_obj: bigint): void {
24616 if(!isWasmInitialized) {
24617 throw new Error("initializeWasm() must be awaited first!");
24619 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
24620 // debug statements here
24622 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
24624 export function BigSize_get_a(this_ptr: bigint): bigint {
24625 if(!isWasmInitialized) {
24626 throw new Error("initializeWasm() must be awaited first!");
24628 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
24629 return nativeResponseValue;
24631 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
24633 export function BigSize_set_a(this_ptr: bigint, val: bigint): void {
24634 if(!isWasmInitialized) {
24635 throw new Error("initializeWasm() must be awaited first!");
24637 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
24638 // debug statements here
24640 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
24642 export function BigSize_new(a_arg: bigint): bigint {
24643 if(!isWasmInitialized) {
24644 throw new Error("initializeWasm() must be awaited first!");
24646 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
24647 return nativeResponseValue;
24649 // uint64_t BigSize_clone_ptr(LDKBigSize *NONNULL_PTR arg);
24651 export function BigSize_clone_ptr(arg: bigint): bigint {
24652 if(!isWasmInitialized) {
24653 throw new Error("initializeWasm() must be awaited first!");
24655 const nativeResponseValue = wasm.TS_BigSize_clone_ptr(arg);
24656 return nativeResponseValue;
24658 // struct LDKBigSize BigSize_clone(const struct LDKBigSize *NONNULL_PTR orig);
24660 export function BigSize_clone(orig: bigint): bigint {
24661 if(!isWasmInitialized) {
24662 throw new Error("initializeWasm() must be awaited first!");
24664 const nativeResponseValue = wasm.TS_BigSize_clone(orig);
24665 return nativeResponseValue;
24667 // uint64_t BigSize_hash(const struct LDKBigSize *NONNULL_PTR o);
24669 export function BigSize_hash(o: bigint): bigint {
24670 if(!isWasmInitialized) {
24671 throw new Error("initializeWasm() must be awaited first!");
24673 const nativeResponseValue = wasm.TS_BigSize_hash(o);
24674 return nativeResponseValue;
24676 // bool BigSize_eq(const struct LDKBigSize *NONNULL_PTR a, const struct LDKBigSize *NONNULL_PTR b);
24678 export function BigSize_eq(a: bigint, b: bigint): boolean {
24679 if(!isWasmInitialized) {
24680 throw new Error("initializeWasm() must be awaited first!");
24682 const nativeResponseValue = wasm.TS_BigSize_eq(a, b);
24683 return nativeResponseValue;
24685 // struct LDKCVec_u8Z BigSize_write(const struct LDKBigSize *NONNULL_PTR obj);
24687 export function BigSize_write(obj: bigint): number {
24688 if(!isWasmInitialized) {
24689 throw new Error("initializeWasm() must be awaited first!");
24691 const nativeResponseValue = wasm.TS_BigSize_write(obj);
24692 return nativeResponseValue;
24694 // struct LDKCResult_BigSizeDecodeErrorZ BigSize_read(struct LDKu8slice ser);
24696 export function BigSize_read(ser: number): bigint {
24697 if(!isWasmInitialized) {
24698 throw new Error("initializeWasm() must be awaited first!");
24700 const nativeResponseValue = wasm.TS_BigSize_read(ser);
24701 return nativeResponseValue;
24703 // void Hostname_free(struct LDKHostname this_obj);
24705 export function Hostname_free(this_obj: bigint): void {
24706 if(!isWasmInitialized) {
24707 throw new Error("initializeWasm() must be awaited first!");
24709 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
24710 // debug statements here
24712 // uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
24714 export function Hostname_clone_ptr(arg: bigint): bigint {
24715 if(!isWasmInitialized) {
24716 throw new Error("initializeWasm() must be awaited first!");
24718 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
24719 return nativeResponseValue;
24721 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
24723 export function Hostname_clone(orig: bigint): bigint {
24724 if(!isWasmInitialized) {
24725 throw new Error("initializeWasm() must be awaited first!");
24727 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
24728 return nativeResponseValue;
24730 // bool Hostname_eq(const struct LDKHostname *NONNULL_PTR a, const struct LDKHostname *NONNULL_PTR b);
24732 export function Hostname_eq(a: bigint, b: bigint): boolean {
24733 if(!isWasmInitialized) {
24734 throw new Error("initializeWasm() must be awaited first!");
24736 const nativeResponseValue = wasm.TS_Hostname_eq(a, b);
24737 return nativeResponseValue;
24739 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
24741 export function Hostname_len(this_arg: bigint): number {
24742 if(!isWasmInitialized) {
24743 throw new Error("initializeWasm() must be awaited first!");
24745 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
24746 return nativeResponseValue;
24748 // struct LDKCVec_u8Z Hostname_write(const struct LDKHostname *NONNULL_PTR obj);
24750 export function Hostname_write(obj: bigint): number {
24751 if(!isWasmInitialized) {
24752 throw new Error("initializeWasm() must be awaited first!");
24754 const nativeResponseValue = wasm.TS_Hostname_write(obj);
24755 return nativeResponseValue;
24757 // struct LDKCResult_HostnameDecodeErrorZ Hostname_read(struct LDKu8slice ser);
24759 export function Hostname_read(ser: number): bigint {
24760 if(!isWasmInitialized) {
24761 throw new Error("initializeWasm() must be awaited first!");
24763 const nativeResponseValue = wasm.TS_Hostname_read(ser);
24764 return nativeResponseValue;
24766 // void TransactionU16LenLimited_free(struct LDKTransactionU16LenLimited this_obj);
24768 export function TransactionU16LenLimited_free(this_obj: bigint): void {
24769 if(!isWasmInitialized) {
24770 throw new Error("initializeWasm() must be awaited first!");
24772 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_free(this_obj);
24773 // debug statements here
24775 // uint64_t TransactionU16LenLimited_clone_ptr(LDKTransactionU16LenLimited *NONNULL_PTR arg);
24777 export function TransactionU16LenLimited_clone_ptr(arg: bigint): bigint {
24778 if(!isWasmInitialized) {
24779 throw new Error("initializeWasm() must be awaited first!");
24781 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone_ptr(arg);
24782 return nativeResponseValue;
24784 // struct LDKTransactionU16LenLimited TransactionU16LenLimited_clone(const struct LDKTransactionU16LenLimited *NONNULL_PTR orig);
24786 export function TransactionU16LenLimited_clone(orig: bigint): bigint {
24787 if(!isWasmInitialized) {
24788 throw new Error("initializeWasm() must be awaited first!");
24790 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone(orig);
24791 return nativeResponseValue;
24793 // bool TransactionU16LenLimited_eq(const struct LDKTransactionU16LenLimited *NONNULL_PTR a, const struct LDKTransactionU16LenLimited *NONNULL_PTR b);
24795 export function TransactionU16LenLimited_eq(a: bigint, b: bigint): boolean {
24796 if(!isWasmInitialized) {
24797 throw new Error("initializeWasm() must be awaited first!");
24799 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_eq(a, b);
24800 return nativeResponseValue;
24802 // MUST_USE_RES struct LDKCResult_TransactionU16LenLimitedNoneZ TransactionU16LenLimited_new(struct LDKTransaction transaction);
24804 export function TransactionU16LenLimited_new(transaction: number): bigint {
24805 if(!isWasmInitialized) {
24806 throw new Error("initializeWasm() must be awaited first!");
24808 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_new(transaction);
24809 return nativeResponseValue;
24811 // MUST_USE_RES struct LDKTransaction TransactionU16LenLimited_into_transaction(struct LDKTransactionU16LenLimited this_arg);
24813 export function TransactionU16LenLimited_into_transaction(this_arg: bigint): number {
24814 if(!isWasmInitialized) {
24815 throw new Error("initializeWasm() must be awaited first!");
24817 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_into_transaction(this_arg);
24818 return nativeResponseValue;
24820 // struct LDKCVec_u8Z TransactionU16LenLimited_write(const struct LDKTransactionU16LenLimited *NONNULL_PTR obj);
24822 export function TransactionU16LenLimited_write(obj: bigint): number {
24823 if(!isWasmInitialized) {
24824 throw new Error("initializeWasm() must be awaited first!");
24826 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_write(obj);
24827 return nativeResponseValue;
24829 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ TransactionU16LenLimited_read(struct LDKu8slice ser);
24831 export function TransactionU16LenLimited_read(ser: number): bigint {
24832 if(!isWasmInitialized) {
24833 throw new Error("initializeWasm() must be awaited first!");
24835 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_read(ser);
24836 return nativeResponseValue;
24838 // struct LDKCResult_StrSecp256k1ErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
24840 export function sign(msg: number, sk: number): bigint {
24841 if(!isWasmInitialized) {
24842 throw new Error("initializeWasm() must be awaited first!");
24844 const nativeResponseValue = wasm.TS_sign(msg, sk);
24845 return nativeResponseValue;
24847 // struct LDKCResult_PublicKeySecp256k1ErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
24849 export function recover_pk(msg: number, sig: number): bigint {
24850 if(!isWasmInitialized) {
24851 throw new Error("initializeWasm() must be awaited first!");
24853 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
24854 return nativeResponseValue;
24856 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
24858 export function verify(msg: number, sig: number, pk: number): boolean {
24859 if(!isWasmInitialized) {
24860 throw new Error("initializeWasm() must be awaited first!");
24862 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
24863 return nativeResponseValue;
24865 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z data_without_signature);
24867 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
24868 if(!isWasmInitialized) {
24869 throw new Error("initializeWasm() must be awaited first!");
24871 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
24872 return nativeResponseValue;
24874 // void KVStore_free(struct LDKKVStore this_ptr);
24876 export function KVStore_free(this_ptr: bigint): void {
24877 if(!isWasmInitialized) {
24878 throw new Error("initializeWasm() must be awaited first!");
24880 const nativeResponseValue = wasm.TS_KVStore_free(this_ptr);
24881 // debug statements here
24883 // void Persister_free(struct LDKPersister this_ptr);
24885 export function Persister_free(this_ptr: bigint): void {
24886 if(!isWasmInitialized) {
24887 throw new Error("initializeWasm() must be awaited first!");
24889 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
24890 // debug statements here
24892 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ read_channel_monitors(struct LDKKVStore kv_store, struct LDKEntropySource entropy_source, struct LDKSignerProvider signer_provider);
24894 export function read_channel_monitors(kv_store: bigint, entropy_source: bigint, signer_provider: bigint): bigint {
24895 if(!isWasmInitialized) {
24896 throw new Error("initializeWasm() must be awaited first!");
24898 const nativeResponseValue = wasm.TS_read_channel_monitors(kv_store, entropy_source, signer_provider);
24899 return nativeResponseValue;
24901 // void MonitorUpdatingPersister_free(struct LDKMonitorUpdatingPersister this_obj);
24903 export function MonitorUpdatingPersister_free(this_obj: bigint): void {
24904 if(!isWasmInitialized) {
24905 throw new Error("initializeWasm() must be awaited first!");
24907 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_free(this_obj);
24908 // debug statements here
24910 // 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);
24912 export function MonitorUpdatingPersister_new(kv_store: bigint, logger: bigint, maximum_pending_updates: bigint, entropy_source: bigint, signer_provider: bigint): bigint {
24913 if(!isWasmInitialized) {
24914 throw new Error("initializeWasm() must be awaited first!");
24916 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_new(kv_store, logger, maximum_pending_updates, entropy_source, signer_provider);
24917 return nativeResponseValue;
24919 // 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);
24921 export function MonitorUpdatingPersister_read_all_channel_monitors_with_updates(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint): bigint {
24922 if(!isWasmInitialized) {
24923 throw new Error("initializeWasm() must be awaited first!");
24925 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_read_all_channel_monitors_with_updates(this_arg, broadcaster, fee_estimator);
24926 return nativeResponseValue;
24928 // 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);
24930 export function MonitorUpdatingPersister_read_channel_monitor_with_updates(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, monitor_key: number): bigint {
24931 if(!isWasmInitialized) {
24932 throw new Error("initializeWasm() must be awaited first!");
24934 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_read_channel_monitor_with_updates(this_arg, broadcaster, fee_estimator, monitor_key);
24935 return nativeResponseValue;
24937 // MUST_USE_RES struct LDKCResult_NoneIOErrorZ MonitorUpdatingPersister_cleanup_stale_updates(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg, bool lazy);
24939 export function MonitorUpdatingPersister_cleanup_stale_updates(this_arg: bigint, lazy: boolean): bigint {
24940 if(!isWasmInitialized) {
24941 throw new Error("initializeWasm() must be awaited first!");
24943 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_cleanup_stale_updates(this_arg, lazy);
24944 return nativeResponseValue;
24946 // struct LDKPersist MonitorUpdatingPersister_as_Persist(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg);
24948 export function MonitorUpdatingPersister_as_Persist(this_arg: bigint): bigint {
24949 if(!isWasmInitialized) {
24950 throw new Error("initializeWasm() must be awaited first!");
24952 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_as_Persist(this_arg);
24953 return nativeResponseValue;
24955 // void UntrustedString_free(struct LDKUntrustedString this_obj);
24957 export function UntrustedString_free(this_obj: bigint): void {
24958 if(!isWasmInitialized) {
24959 throw new Error("initializeWasm() must be awaited first!");
24961 const nativeResponseValue = wasm.TS_UntrustedString_free(this_obj);
24962 // debug statements here
24964 // struct LDKStr UntrustedString_get_a(const struct LDKUntrustedString *NONNULL_PTR this_ptr);
24966 export function UntrustedString_get_a(this_ptr: bigint): number {
24967 if(!isWasmInitialized) {
24968 throw new Error("initializeWasm() must be awaited first!");
24970 const nativeResponseValue = wasm.TS_UntrustedString_get_a(this_ptr);
24971 return nativeResponseValue;
24973 // void UntrustedString_set_a(struct LDKUntrustedString *NONNULL_PTR this_ptr, struct LDKStr val);
24975 export function UntrustedString_set_a(this_ptr: bigint, val: number): void {
24976 if(!isWasmInitialized) {
24977 throw new Error("initializeWasm() must be awaited first!");
24979 const nativeResponseValue = wasm.TS_UntrustedString_set_a(this_ptr, val);
24980 // debug statements here
24982 // MUST_USE_RES struct LDKUntrustedString UntrustedString_new(struct LDKStr a_arg);
24984 export function UntrustedString_new(a_arg: number): bigint {
24985 if(!isWasmInitialized) {
24986 throw new Error("initializeWasm() must be awaited first!");
24988 const nativeResponseValue = wasm.TS_UntrustedString_new(a_arg);
24989 return nativeResponseValue;
24991 // uint64_t UntrustedString_clone_ptr(LDKUntrustedString *NONNULL_PTR arg);
24993 export function UntrustedString_clone_ptr(arg: bigint): bigint {
24994 if(!isWasmInitialized) {
24995 throw new Error("initializeWasm() must be awaited first!");
24997 const nativeResponseValue = wasm.TS_UntrustedString_clone_ptr(arg);
24998 return nativeResponseValue;
25000 // struct LDKUntrustedString UntrustedString_clone(const struct LDKUntrustedString *NONNULL_PTR orig);
25002 export function UntrustedString_clone(orig: bigint): bigint {
25003 if(!isWasmInitialized) {
25004 throw new Error("initializeWasm() must be awaited first!");
25006 const nativeResponseValue = wasm.TS_UntrustedString_clone(orig);
25007 return nativeResponseValue;
25009 // bool UntrustedString_eq(const struct LDKUntrustedString *NONNULL_PTR a, const struct LDKUntrustedString *NONNULL_PTR b);
25011 export function UntrustedString_eq(a: bigint, b: bigint): boolean {
25012 if(!isWasmInitialized) {
25013 throw new Error("initializeWasm() must be awaited first!");
25015 const nativeResponseValue = wasm.TS_UntrustedString_eq(a, b);
25016 return nativeResponseValue;
25018 // struct LDKCVec_u8Z UntrustedString_write(const struct LDKUntrustedString *NONNULL_PTR obj);
25020 export function UntrustedString_write(obj: bigint): number {
25021 if(!isWasmInitialized) {
25022 throw new Error("initializeWasm() must be awaited first!");
25024 const nativeResponseValue = wasm.TS_UntrustedString_write(obj);
25025 return nativeResponseValue;
25027 // struct LDKCResult_UntrustedStringDecodeErrorZ UntrustedString_read(struct LDKu8slice ser);
25029 export function UntrustedString_read(ser: number): bigint {
25030 if(!isWasmInitialized) {
25031 throw new Error("initializeWasm() must be awaited first!");
25033 const nativeResponseValue = wasm.TS_UntrustedString_read(ser);
25034 return nativeResponseValue;
25036 // void PrintableString_free(struct LDKPrintableString this_obj);
25038 export function PrintableString_free(this_obj: bigint): void {
25039 if(!isWasmInitialized) {
25040 throw new Error("initializeWasm() must be awaited first!");
25042 const nativeResponseValue = wasm.TS_PrintableString_free(this_obj);
25043 // debug statements here
25045 // struct LDKStr PrintableString_get_a(const struct LDKPrintableString *NONNULL_PTR this_ptr);
25047 export function PrintableString_get_a(this_ptr: bigint): number {
25048 if(!isWasmInitialized) {
25049 throw new Error("initializeWasm() must be awaited first!");
25051 const nativeResponseValue = wasm.TS_PrintableString_get_a(this_ptr);
25052 return nativeResponseValue;
25054 // void PrintableString_set_a(struct LDKPrintableString *NONNULL_PTR this_ptr, struct LDKStr val);
25056 export function PrintableString_set_a(this_ptr: bigint, val: number): void {
25057 if(!isWasmInitialized) {
25058 throw new Error("initializeWasm() must be awaited first!");
25060 const nativeResponseValue = wasm.TS_PrintableString_set_a(this_ptr, val);
25061 // debug statements here
25063 // MUST_USE_RES struct LDKPrintableString PrintableString_new(struct LDKStr a_arg);
25065 export function PrintableString_new(a_arg: number): bigint {
25066 if(!isWasmInitialized) {
25067 throw new Error("initializeWasm() must be awaited first!");
25069 const nativeResponseValue = wasm.TS_PrintableString_new(a_arg);
25070 return nativeResponseValue;
25072 // void FutureCallback_free(struct LDKFutureCallback this_ptr);
25074 export function FutureCallback_free(this_ptr: bigint): void {
25075 if(!isWasmInitialized) {
25076 throw new Error("initializeWasm() must be awaited first!");
25078 const nativeResponseValue = wasm.TS_FutureCallback_free(this_ptr);
25079 // debug statements here
25081 // void Future_free(struct LDKFuture this_obj);
25083 export function Future_free(this_obj: bigint): void {
25084 if(!isWasmInitialized) {
25085 throw new Error("initializeWasm() must be awaited first!");
25087 const nativeResponseValue = wasm.TS_Future_free(this_obj);
25088 // debug statements here
25090 // uint64_t Future_clone_ptr(LDKFuture *NONNULL_PTR arg);
25092 export function Future_clone_ptr(arg: bigint): bigint {
25093 if(!isWasmInitialized) {
25094 throw new Error("initializeWasm() must be awaited first!");
25096 const nativeResponseValue = wasm.TS_Future_clone_ptr(arg);
25097 return nativeResponseValue;
25099 // struct LDKFuture Future_clone(const struct LDKFuture *NONNULL_PTR orig);
25101 export function Future_clone(orig: bigint): bigint {
25102 if(!isWasmInitialized) {
25103 throw new Error("initializeWasm() must be awaited first!");
25105 const nativeResponseValue = wasm.TS_Future_clone(orig);
25106 return nativeResponseValue;
25108 // void Future_register_callback_fn(const struct LDKFuture *NONNULL_PTR this_arg, struct LDKFutureCallback callback);
25110 export function Future_register_callback_fn(this_arg: bigint, callback: bigint): void {
25111 if(!isWasmInitialized) {
25112 throw new Error("initializeWasm() must be awaited first!");
25114 const nativeResponseValue = wasm.TS_Future_register_callback_fn(this_arg, callback);
25115 // debug statements here
25117 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
25119 export function Level_clone(orig: bigint): Level {
25120 if(!isWasmInitialized) {
25121 throw new Error("initializeWasm() must be awaited first!");
25123 const nativeResponseValue = wasm.TS_Level_clone(orig);
25124 return nativeResponseValue;
25126 // enum LDKLevel Level_gossip(void);
25128 export function Level_gossip(): Level {
25129 if(!isWasmInitialized) {
25130 throw new Error("initializeWasm() must be awaited first!");
25132 const nativeResponseValue = wasm.TS_Level_gossip();
25133 return nativeResponseValue;
25135 // enum LDKLevel Level_trace(void);
25137 export function Level_trace(): Level {
25138 if(!isWasmInitialized) {
25139 throw new Error("initializeWasm() must be awaited first!");
25141 const nativeResponseValue = wasm.TS_Level_trace();
25142 return nativeResponseValue;
25144 // enum LDKLevel Level_debug(void);
25146 export function Level_debug(): Level {
25147 if(!isWasmInitialized) {
25148 throw new Error("initializeWasm() must be awaited first!");
25150 const nativeResponseValue = wasm.TS_Level_debug();
25151 return nativeResponseValue;
25153 // enum LDKLevel Level_info(void);
25155 export function Level_info(): Level {
25156 if(!isWasmInitialized) {
25157 throw new Error("initializeWasm() must be awaited first!");
25159 const nativeResponseValue = wasm.TS_Level_info();
25160 return nativeResponseValue;
25162 // enum LDKLevel Level_warn(void);
25164 export function Level_warn(): Level {
25165 if(!isWasmInitialized) {
25166 throw new Error("initializeWasm() must be awaited first!");
25168 const nativeResponseValue = wasm.TS_Level_warn();
25169 return nativeResponseValue;
25171 // enum LDKLevel Level_error(void);
25173 export function Level_error(): Level {
25174 if(!isWasmInitialized) {
25175 throw new Error("initializeWasm() must be awaited first!");
25177 const nativeResponseValue = wasm.TS_Level_error();
25178 return nativeResponseValue;
25180 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
25182 export function Level_eq(a: bigint, b: bigint): boolean {
25183 if(!isWasmInitialized) {
25184 throw new Error("initializeWasm() must be awaited first!");
25186 const nativeResponseValue = wasm.TS_Level_eq(a, b);
25187 return nativeResponseValue;
25189 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
25191 export function Level_hash(o: bigint): bigint {
25192 if(!isWasmInitialized) {
25193 throw new Error("initializeWasm() must be awaited first!");
25195 const nativeResponseValue = wasm.TS_Level_hash(o);
25196 return nativeResponseValue;
25198 // MUST_USE_RES enum LDKLevel Level_max(void);
25200 export function Level_max(): Level {
25201 if(!isWasmInitialized) {
25202 throw new Error("initializeWasm() must be awaited first!");
25204 const nativeResponseValue = wasm.TS_Level_max();
25205 return nativeResponseValue;
25207 // void Record_free(struct LDKRecord this_obj);
25209 export function Record_free(this_obj: bigint): void {
25210 if(!isWasmInitialized) {
25211 throw new Error("initializeWasm() must be awaited first!");
25213 const nativeResponseValue = wasm.TS_Record_free(this_obj);
25214 // debug statements here
25216 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
25218 export function Record_get_level(this_ptr: bigint): Level {
25219 if(!isWasmInitialized) {
25220 throw new Error("initializeWasm() must be awaited first!");
25222 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
25223 return nativeResponseValue;
25225 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
25227 export function Record_set_level(this_ptr: bigint, val: Level): void {
25228 if(!isWasmInitialized) {
25229 throw new Error("initializeWasm() must be awaited first!");
25231 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
25232 // debug statements here
25234 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
25236 export function Record_get_args(this_ptr: bigint): number {
25237 if(!isWasmInitialized) {
25238 throw new Error("initializeWasm() must be awaited first!");
25240 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
25241 return nativeResponseValue;
25243 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
25245 export function Record_set_args(this_ptr: bigint, val: number): void {
25246 if(!isWasmInitialized) {
25247 throw new Error("initializeWasm() must be awaited first!");
25249 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
25250 // debug statements here
25252 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
25254 export function Record_get_module_path(this_ptr: bigint): number {
25255 if(!isWasmInitialized) {
25256 throw new Error("initializeWasm() must be awaited first!");
25258 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
25259 return nativeResponseValue;
25261 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
25263 export function Record_set_module_path(this_ptr: bigint, val: number): void {
25264 if(!isWasmInitialized) {
25265 throw new Error("initializeWasm() must be awaited first!");
25267 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
25268 // debug statements here
25270 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
25272 export function Record_get_file(this_ptr: bigint): number {
25273 if(!isWasmInitialized) {
25274 throw new Error("initializeWasm() must be awaited first!");
25276 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
25277 return nativeResponseValue;
25279 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
25281 export function Record_set_file(this_ptr: bigint, val: number): void {
25282 if(!isWasmInitialized) {
25283 throw new Error("initializeWasm() must be awaited first!");
25285 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
25286 // debug statements here
25288 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
25290 export function Record_get_line(this_ptr: bigint): number {
25291 if(!isWasmInitialized) {
25292 throw new Error("initializeWasm() must be awaited first!");
25294 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
25295 return nativeResponseValue;
25297 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
25299 export function Record_set_line(this_ptr: bigint, val: number): void {
25300 if(!isWasmInitialized) {
25301 throw new Error("initializeWasm() must be awaited first!");
25303 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
25304 // debug statements here
25306 // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
25308 export function Record_clone_ptr(arg: bigint): bigint {
25309 if(!isWasmInitialized) {
25310 throw new Error("initializeWasm() must be awaited first!");
25312 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
25313 return nativeResponseValue;
25315 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
25317 export function Record_clone(orig: bigint): bigint {
25318 if(!isWasmInitialized) {
25319 throw new Error("initializeWasm() must be awaited first!");
25321 const nativeResponseValue = wasm.TS_Record_clone(orig);
25322 return nativeResponseValue;
25324 // void Logger_free(struct LDKLogger this_ptr);
25326 export function Logger_free(this_ptr: bigint): void {
25327 if(!isWasmInitialized) {
25328 throw new Error("initializeWasm() must be awaited first!");
25330 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
25331 // debug statements here
25333 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
25335 export function ChannelHandshakeConfig_free(this_obj: bigint): void {
25336 if(!isWasmInitialized) {
25337 throw new Error("initializeWasm() must be awaited first!");
25339 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
25340 // debug statements here
25342 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25344 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: bigint): number {
25345 if(!isWasmInitialized) {
25346 throw new Error("initializeWasm() must be awaited first!");
25348 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
25349 return nativeResponseValue;
25351 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
25353 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: bigint, val: number): void {
25354 if(!isWasmInitialized) {
25355 throw new Error("initializeWasm() must be awaited first!");
25357 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
25358 // debug statements here
25360 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25362 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: bigint): number {
25363 if(!isWasmInitialized) {
25364 throw new Error("initializeWasm() must be awaited first!");
25366 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
25367 return nativeResponseValue;
25369 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
25371 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: bigint, val: number): void {
25372 if(!isWasmInitialized) {
25373 throw new Error("initializeWasm() must be awaited first!");
25375 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
25376 // debug statements here
25378 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25380 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: bigint): bigint {
25381 if(!isWasmInitialized) {
25382 throw new Error("initializeWasm() must be awaited first!");
25384 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
25385 return nativeResponseValue;
25387 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
25389 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
25390 if(!isWasmInitialized) {
25391 throw new Error("initializeWasm() must be awaited first!");
25393 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
25394 // debug statements here
25396 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25398 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint): number {
25399 if(!isWasmInitialized) {
25400 throw new Error("initializeWasm() must be awaited first!");
25402 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
25403 return nativeResponseValue;
25405 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
25407 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint, val: number): void {
25408 if(!isWasmInitialized) {
25409 throw new Error("initializeWasm() must be awaited first!");
25411 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
25412 // debug statements here
25414 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25416 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: bigint): boolean {
25417 if(!isWasmInitialized) {
25418 throw new Error("initializeWasm() must be awaited first!");
25420 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
25421 return nativeResponseValue;
25423 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
25425 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: bigint, val: boolean): void {
25426 if(!isWasmInitialized) {
25427 throw new Error("initializeWasm() must be awaited first!");
25429 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
25430 // debug statements here
25432 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25434 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: bigint): boolean {
25435 if(!isWasmInitialized) {
25436 throw new Error("initializeWasm() must be awaited first!");
25438 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
25439 return nativeResponseValue;
25441 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
25443 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: bigint, val: boolean): void {
25444 if(!isWasmInitialized) {
25445 throw new Error("initializeWasm() must be awaited first!");
25447 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
25448 // debug statements here
25450 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25452 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: bigint): boolean {
25453 if(!isWasmInitialized) {
25454 throw new Error("initializeWasm() must be awaited first!");
25456 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
25457 return nativeResponseValue;
25459 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
25461 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: bigint, val: boolean): void {
25462 if(!isWasmInitialized) {
25463 throw new Error("initializeWasm() must be awaited first!");
25465 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
25466 // debug statements here
25468 // uint32_t ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25470 export function ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr: bigint): number {
25471 if(!isWasmInitialized) {
25472 throw new Error("initializeWasm() must be awaited first!");
25474 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr);
25475 return nativeResponseValue;
25477 // void ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
25479 export function ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr: bigint, val: number): void {
25480 if(!isWasmInitialized) {
25481 throw new Error("initializeWasm() must be awaited first!");
25483 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr, val);
25484 // debug statements here
25486 // bool ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25488 export function ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(this_ptr: bigint): boolean {
25489 if(!isWasmInitialized) {
25490 throw new Error("initializeWasm() must be awaited first!");
25492 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(this_ptr);
25493 return nativeResponseValue;
25495 // void ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
25497 export function ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(this_ptr: bigint, val: boolean): void {
25498 if(!isWasmInitialized) {
25499 throw new Error("initializeWasm() must be awaited first!");
25501 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(this_ptr, val);
25502 // debug statements here
25504 // uint16_t ChannelHandshakeConfig_get_our_max_accepted_htlcs(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
25506 export function ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr: bigint): number {
25507 if(!isWasmInitialized) {
25508 throw new Error("initializeWasm() must be awaited first!");
25510 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr);
25511 return nativeResponseValue;
25513 // void ChannelHandshakeConfig_set_our_max_accepted_htlcs(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
25515 export function ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr: bigint, val: number): void {
25516 if(!isWasmInitialized) {
25517 throw new Error("initializeWasm() must be awaited first!");
25519 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr, val);
25520 // debug statements here
25522 // 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);
25524 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 {
25525 if(!isWasmInitialized) {
25526 throw new Error("initializeWasm() must be awaited first!");
25528 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);
25529 return nativeResponseValue;
25531 // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
25533 export function ChannelHandshakeConfig_clone_ptr(arg: bigint): bigint {
25534 if(!isWasmInitialized) {
25535 throw new Error("initializeWasm() must be awaited first!");
25537 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
25538 return nativeResponseValue;
25540 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
25542 export function ChannelHandshakeConfig_clone(orig: bigint): bigint {
25543 if(!isWasmInitialized) {
25544 throw new Error("initializeWasm() must be awaited first!");
25546 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
25547 return nativeResponseValue;
25549 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
25551 export function ChannelHandshakeConfig_default(): bigint {
25552 if(!isWasmInitialized) {
25553 throw new Error("initializeWasm() must be awaited first!");
25555 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
25556 return nativeResponseValue;
25558 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
25560 export function ChannelHandshakeLimits_free(this_obj: bigint): void {
25561 if(!isWasmInitialized) {
25562 throw new Error("initializeWasm() must be awaited first!");
25564 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
25565 // debug statements here
25567 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25569 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: bigint): bigint {
25570 if(!isWasmInitialized) {
25571 throw new Error("initializeWasm() must be awaited first!");
25573 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
25574 return nativeResponseValue;
25576 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
25578 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: bigint, val: bigint): void {
25579 if(!isWasmInitialized) {
25580 throw new Error("initializeWasm() must be awaited first!");
25582 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
25583 // debug statements here
25585 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25587 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: bigint): bigint {
25588 if(!isWasmInitialized) {
25589 throw new Error("initializeWasm() must be awaited first!");
25591 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
25592 return nativeResponseValue;
25594 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
25596 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: bigint, val: bigint): void {
25597 if(!isWasmInitialized) {
25598 throw new Error("initializeWasm() must be awaited first!");
25600 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
25601 // debug statements here
25603 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25605 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: bigint): bigint {
25606 if(!isWasmInitialized) {
25607 throw new Error("initializeWasm() must be awaited first!");
25609 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
25610 return nativeResponseValue;
25612 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
25614 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
25615 if(!isWasmInitialized) {
25616 throw new Error("initializeWasm() must be awaited first!");
25618 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
25619 // debug statements here
25621 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25623 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
25624 if(!isWasmInitialized) {
25625 throw new Error("initializeWasm() must be awaited first!");
25627 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
25628 return nativeResponseValue;
25630 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
25632 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
25633 if(!isWasmInitialized) {
25634 throw new Error("initializeWasm() must be awaited first!");
25636 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
25637 // debug statements here
25639 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25641 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: bigint): bigint {
25642 if(!isWasmInitialized) {
25643 throw new Error("initializeWasm() must be awaited first!");
25645 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
25646 return nativeResponseValue;
25648 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
25650 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
25651 if(!isWasmInitialized) {
25652 throw new Error("initializeWasm() must be awaited first!");
25654 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
25655 // debug statements here
25657 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25659 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: bigint): number {
25660 if(!isWasmInitialized) {
25661 throw new Error("initializeWasm() must be awaited first!");
25663 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
25664 return nativeResponseValue;
25666 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
25668 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: bigint, val: number): void {
25669 if(!isWasmInitialized) {
25670 throw new Error("initializeWasm() must be awaited first!");
25672 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
25673 // debug statements here
25675 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25677 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: bigint): number {
25678 if(!isWasmInitialized) {
25679 throw new Error("initializeWasm() must be awaited first!");
25681 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
25682 return nativeResponseValue;
25684 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
25686 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: bigint, val: number): void {
25687 if(!isWasmInitialized) {
25688 throw new Error("initializeWasm() must be awaited first!");
25690 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
25691 // debug statements here
25693 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25695 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: bigint): boolean {
25696 if(!isWasmInitialized) {
25697 throw new Error("initializeWasm() must be awaited first!");
25699 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
25700 return nativeResponseValue;
25702 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
25704 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: bigint, val: boolean): void {
25705 if(!isWasmInitialized) {
25706 throw new Error("initializeWasm() must be awaited first!");
25708 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
25709 // debug statements here
25711 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25713 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: bigint): boolean {
25714 if(!isWasmInitialized) {
25715 throw new Error("initializeWasm() must be awaited first!");
25717 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
25718 return nativeResponseValue;
25720 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
25722 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: bigint, val: boolean): void {
25723 if(!isWasmInitialized) {
25724 throw new Error("initializeWasm() must be awaited first!");
25726 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
25727 // debug statements here
25729 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
25731 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: bigint): number {
25732 if(!isWasmInitialized) {
25733 throw new Error("initializeWasm() must be awaited first!");
25735 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
25736 return nativeResponseValue;
25738 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
25740 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: bigint, val: number): void {
25741 if(!isWasmInitialized) {
25742 throw new Error("initializeWasm() must be awaited first!");
25744 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
25745 // debug statements here
25747 // 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);
25749 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 {
25750 if(!isWasmInitialized) {
25751 throw new Error("initializeWasm() must be awaited first!");
25753 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);
25754 return nativeResponseValue;
25756 // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
25758 export function ChannelHandshakeLimits_clone_ptr(arg: bigint): bigint {
25759 if(!isWasmInitialized) {
25760 throw new Error("initializeWasm() must be awaited first!");
25762 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
25763 return nativeResponseValue;
25765 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
25767 export function ChannelHandshakeLimits_clone(orig: bigint): bigint {
25768 if(!isWasmInitialized) {
25769 throw new Error("initializeWasm() must be awaited first!");
25771 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
25772 return nativeResponseValue;
25774 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
25776 export function ChannelHandshakeLimits_default(): bigint {
25777 if(!isWasmInitialized) {
25778 throw new Error("initializeWasm() must be awaited first!");
25780 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
25781 return nativeResponseValue;
25783 // void MaxDustHTLCExposure_free(struct LDKMaxDustHTLCExposure this_ptr);
25785 export function MaxDustHTLCExposure_free(this_ptr: bigint): void {
25786 if(!isWasmInitialized) {
25787 throw new Error("initializeWasm() must be awaited first!");
25789 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_free(this_ptr);
25790 // debug statements here
25792 // uint64_t MaxDustHTLCExposure_clone_ptr(LDKMaxDustHTLCExposure *NONNULL_PTR arg);
25794 export function MaxDustHTLCExposure_clone_ptr(arg: bigint): bigint {
25795 if(!isWasmInitialized) {
25796 throw new Error("initializeWasm() must be awaited first!");
25798 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_clone_ptr(arg);
25799 return nativeResponseValue;
25801 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_clone(const struct LDKMaxDustHTLCExposure *NONNULL_PTR orig);
25803 export function MaxDustHTLCExposure_clone(orig: bigint): bigint {
25804 if(!isWasmInitialized) {
25805 throw new Error("initializeWasm() must be awaited first!");
25807 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_clone(orig);
25808 return nativeResponseValue;
25810 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_fixed_limit_msat(uint64_t a);
25812 export function MaxDustHTLCExposure_fixed_limit_msat(a: bigint): bigint {
25813 if(!isWasmInitialized) {
25814 throw new Error("initializeWasm() must be awaited first!");
25816 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_fixed_limit_msat(a);
25817 return nativeResponseValue;
25819 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_fee_rate_multiplier(uint64_t a);
25821 export function MaxDustHTLCExposure_fee_rate_multiplier(a: bigint): bigint {
25822 if(!isWasmInitialized) {
25823 throw new Error("initializeWasm() must be awaited first!");
25825 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_fee_rate_multiplier(a);
25826 return nativeResponseValue;
25828 // bool MaxDustHTLCExposure_eq(const struct LDKMaxDustHTLCExposure *NONNULL_PTR a, const struct LDKMaxDustHTLCExposure *NONNULL_PTR b);
25830 export function MaxDustHTLCExposure_eq(a: bigint, b: bigint): boolean {
25831 if(!isWasmInitialized) {
25832 throw new Error("initializeWasm() must be awaited first!");
25834 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_eq(a, b);
25835 return nativeResponseValue;
25837 // struct LDKCVec_u8Z MaxDustHTLCExposure_write(const struct LDKMaxDustHTLCExposure *NONNULL_PTR obj);
25839 export function MaxDustHTLCExposure_write(obj: bigint): number {
25840 if(!isWasmInitialized) {
25841 throw new Error("initializeWasm() must be awaited first!");
25843 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_write(obj);
25844 return nativeResponseValue;
25846 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ MaxDustHTLCExposure_read(struct LDKu8slice ser);
25848 export function MaxDustHTLCExposure_read(ser: number): bigint {
25849 if(!isWasmInitialized) {
25850 throw new Error("initializeWasm() must be awaited first!");
25852 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_read(ser);
25853 return nativeResponseValue;
25855 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
25857 export function ChannelConfig_free(this_obj: bigint): void {
25858 if(!isWasmInitialized) {
25859 throw new Error("initializeWasm() must be awaited first!");
25861 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
25862 // debug statements here
25864 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25866 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: bigint): number {
25867 if(!isWasmInitialized) {
25868 throw new Error("initializeWasm() must be awaited first!");
25870 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
25871 return nativeResponseValue;
25873 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
25875 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: number): void {
25876 if(!isWasmInitialized) {
25877 throw new Error("initializeWasm() must be awaited first!");
25879 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
25880 // debug statements here
25882 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25884 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: bigint): number {
25885 if(!isWasmInitialized) {
25886 throw new Error("initializeWasm() must be awaited first!");
25888 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
25889 return nativeResponseValue;
25891 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
25893 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: bigint, val: number): void {
25894 if(!isWasmInitialized) {
25895 throw new Error("initializeWasm() must be awaited first!");
25897 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
25898 // debug statements here
25900 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25902 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: bigint): number {
25903 if(!isWasmInitialized) {
25904 throw new Error("initializeWasm() must be awaited first!");
25906 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
25907 return nativeResponseValue;
25909 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
25911 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
25912 if(!isWasmInitialized) {
25913 throw new Error("initializeWasm() must be awaited first!");
25915 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
25916 // debug statements here
25918 // struct LDKMaxDustHTLCExposure ChannelConfig_get_max_dust_htlc_exposure(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25920 export function ChannelConfig_get_max_dust_htlc_exposure(this_ptr: bigint): bigint {
25921 if(!isWasmInitialized) {
25922 throw new Error("initializeWasm() must be awaited first!");
25924 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure(this_ptr);
25925 return nativeResponseValue;
25927 // void ChannelConfig_set_max_dust_htlc_exposure(struct LDKChannelConfig *NONNULL_PTR this_ptr, struct LDKMaxDustHTLCExposure val);
25929 export function ChannelConfig_set_max_dust_htlc_exposure(this_ptr: bigint, val: bigint): void {
25930 if(!isWasmInitialized) {
25931 throw new Error("initializeWasm() must be awaited first!");
25933 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure(this_ptr, val);
25934 // debug statements here
25936 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25938 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
25939 if(!isWasmInitialized) {
25940 throw new Error("initializeWasm() must be awaited first!");
25942 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
25943 return nativeResponseValue;
25945 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
25947 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
25948 if(!isWasmInitialized) {
25949 throw new Error("initializeWasm() must be awaited first!");
25951 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
25952 // debug statements here
25954 // bool ChannelConfig_get_accept_underpaying_htlcs(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
25956 export function ChannelConfig_get_accept_underpaying_htlcs(this_ptr: bigint): boolean {
25957 if(!isWasmInitialized) {
25958 throw new Error("initializeWasm() must be awaited first!");
25960 const nativeResponseValue = wasm.TS_ChannelConfig_get_accept_underpaying_htlcs(this_ptr);
25961 return nativeResponseValue;
25963 // void ChannelConfig_set_accept_underpaying_htlcs(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
25965 export function ChannelConfig_set_accept_underpaying_htlcs(this_ptr: bigint, val: boolean): void {
25966 if(!isWasmInitialized) {
25967 throw new Error("initializeWasm() must be awaited first!");
25969 const nativeResponseValue = wasm.TS_ChannelConfig_set_accept_underpaying_htlcs(this_ptr, val);
25970 // debug statements here
25972 // 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);
25974 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 {
25975 if(!isWasmInitialized) {
25976 throw new Error("initializeWasm() must be awaited first!");
25978 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);
25979 return nativeResponseValue;
25981 // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
25983 export function ChannelConfig_clone_ptr(arg: bigint): bigint {
25984 if(!isWasmInitialized) {
25985 throw new Error("initializeWasm() must be awaited first!");
25987 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
25988 return nativeResponseValue;
25990 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
25992 export function ChannelConfig_clone(orig: bigint): bigint {
25993 if(!isWasmInitialized) {
25994 throw new Error("initializeWasm() must be awaited first!");
25996 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
25997 return nativeResponseValue;
25999 // bool ChannelConfig_eq(const struct LDKChannelConfig *NONNULL_PTR a, const struct LDKChannelConfig *NONNULL_PTR b);
26001 export function ChannelConfig_eq(a: bigint, b: bigint): boolean {
26002 if(!isWasmInitialized) {
26003 throw new Error("initializeWasm() must be awaited first!");
26005 const nativeResponseValue = wasm.TS_ChannelConfig_eq(a, b);
26006 return nativeResponseValue;
26008 // void ChannelConfig_apply(struct LDKChannelConfig *NONNULL_PTR this_arg, const struct LDKChannelConfigUpdate *NONNULL_PTR update);
26010 export function ChannelConfig_apply(this_arg: bigint, update: bigint): void {
26011 if(!isWasmInitialized) {
26012 throw new Error("initializeWasm() must be awaited first!");
26014 const nativeResponseValue = wasm.TS_ChannelConfig_apply(this_arg, update);
26015 // debug statements here
26017 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
26019 export function ChannelConfig_default(): bigint {
26020 if(!isWasmInitialized) {
26021 throw new Error("initializeWasm() must be awaited first!");
26023 const nativeResponseValue = wasm.TS_ChannelConfig_default();
26024 return nativeResponseValue;
26026 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
26028 export function ChannelConfig_write(obj: bigint): number {
26029 if(!isWasmInitialized) {
26030 throw new Error("initializeWasm() must be awaited first!");
26032 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
26033 return nativeResponseValue;
26035 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
26037 export function ChannelConfig_read(ser: number): bigint {
26038 if(!isWasmInitialized) {
26039 throw new Error("initializeWasm() must be awaited first!");
26041 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
26042 return nativeResponseValue;
26044 // void ChannelConfigUpdate_free(struct LDKChannelConfigUpdate this_obj);
26046 export function ChannelConfigUpdate_free(this_obj: bigint): void {
26047 if(!isWasmInitialized) {
26048 throw new Error("initializeWasm() must be awaited first!");
26050 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_free(this_obj);
26051 // debug statements here
26053 // struct LDKCOption_u32Z ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
26055 export function ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(this_ptr: bigint): bigint {
26056 if(!isWasmInitialized) {
26057 throw new Error("initializeWasm() must be awaited first!");
26059 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(this_ptr);
26060 return nativeResponseValue;
26062 // void ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
26064 export function ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: bigint): void {
26065 if(!isWasmInitialized) {
26066 throw new Error("initializeWasm() must be awaited first!");
26068 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(this_ptr, val);
26069 // debug statements here
26071 // struct LDKCOption_u32Z ChannelConfigUpdate_get_forwarding_fee_base_msat(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
26073 export function ChannelConfigUpdate_get_forwarding_fee_base_msat(this_ptr: bigint): bigint {
26074 if(!isWasmInitialized) {
26075 throw new Error("initializeWasm() must be awaited first!");
26077 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_forwarding_fee_base_msat(this_ptr);
26078 return nativeResponseValue;
26080 // void ChannelConfigUpdate_set_forwarding_fee_base_msat(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
26082 export function ChannelConfigUpdate_set_forwarding_fee_base_msat(this_ptr: bigint, val: bigint): void {
26083 if(!isWasmInitialized) {
26084 throw new Error("initializeWasm() must be awaited first!");
26086 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_forwarding_fee_base_msat(this_ptr, val);
26087 // debug statements here
26089 // struct LDKCOption_u16Z ChannelConfigUpdate_get_cltv_expiry_delta(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
26091 export function ChannelConfigUpdate_get_cltv_expiry_delta(this_ptr: bigint): bigint {
26092 if(!isWasmInitialized) {
26093 throw new Error("initializeWasm() must be awaited first!");
26095 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_cltv_expiry_delta(this_ptr);
26096 return nativeResponseValue;
26098 // void ChannelConfigUpdate_set_cltv_expiry_delta(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
26100 export function ChannelConfigUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: bigint): void {
26101 if(!isWasmInitialized) {
26102 throw new Error("initializeWasm() must be awaited first!");
26104 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_cltv_expiry_delta(this_ptr, val);
26105 // debug statements here
26107 // struct LDKCOption_MaxDustHTLCExposureZ ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
26109 export function ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(this_ptr: bigint): bigint {
26110 if(!isWasmInitialized) {
26111 throw new Error("initializeWasm() must be awaited first!");
26113 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(this_ptr);
26114 return nativeResponseValue;
26116 // void ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_MaxDustHTLCExposureZ val);
26118 export function ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(this_ptr: bigint, val: bigint): void {
26119 if(!isWasmInitialized) {
26120 throw new Error("initializeWasm() must be awaited first!");
26122 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(this_ptr, val);
26123 // debug statements here
26125 // struct LDKCOption_u64Z ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
26127 export function ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
26128 if(!isWasmInitialized) {
26129 throw new Error("initializeWasm() must be awaited first!");
26131 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(this_ptr);
26132 return nativeResponseValue;
26134 // void ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26136 export function ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
26137 if(!isWasmInitialized) {
26138 throw new Error("initializeWasm() must be awaited first!");
26140 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
26141 // debug statements here
26143 // 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);
26145 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 {
26146 if(!isWasmInitialized) {
26147 throw new Error("initializeWasm() must be awaited first!");
26149 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);
26150 return nativeResponseValue;
26152 // MUST_USE_RES struct LDKChannelConfigUpdate ChannelConfigUpdate_default(void);
26154 export function ChannelConfigUpdate_default(): bigint {
26155 if(!isWasmInitialized) {
26156 throw new Error("initializeWasm() must be awaited first!");
26158 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_default();
26159 return nativeResponseValue;
26161 // void UserConfig_free(struct LDKUserConfig this_obj);
26163 export function UserConfig_free(this_obj: bigint): void {
26164 if(!isWasmInitialized) {
26165 throw new Error("initializeWasm() must be awaited first!");
26167 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
26168 // debug statements here
26170 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
26172 export function UserConfig_get_channel_handshake_config(this_ptr: bigint): bigint {
26173 if(!isWasmInitialized) {
26174 throw new Error("initializeWasm() must be awaited first!");
26176 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
26177 return nativeResponseValue;
26179 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
26181 export function UserConfig_set_channel_handshake_config(this_ptr: bigint, val: bigint): void {
26182 if(!isWasmInitialized) {
26183 throw new Error("initializeWasm() must be awaited first!");
26185 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
26186 // debug statements here
26188 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
26190 export function UserConfig_get_channel_handshake_limits(this_ptr: bigint): bigint {
26191 if(!isWasmInitialized) {
26192 throw new Error("initializeWasm() must be awaited first!");
26194 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
26195 return nativeResponseValue;
26197 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
26199 export function UserConfig_set_channel_handshake_limits(this_ptr: bigint, val: bigint): void {
26200 if(!isWasmInitialized) {
26201 throw new Error("initializeWasm() must be awaited first!");
26203 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
26204 // debug statements here
26206 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
26208 export function UserConfig_get_channel_config(this_ptr: bigint): bigint {
26209 if(!isWasmInitialized) {
26210 throw new Error("initializeWasm() must be awaited first!");
26212 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
26213 return nativeResponseValue;
26215 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
26217 export function UserConfig_set_channel_config(this_ptr: bigint, val: bigint): void {
26218 if(!isWasmInitialized) {
26219 throw new Error("initializeWasm() must be awaited first!");
26221 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
26222 // debug statements here
26224 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
26226 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: bigint): boolean {
26227 if(!isWasmInitialized) {
26228 throw new Error("initializeWasm() must be awaited first!");
26230 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
26231 return nativeResponseValue;
26233 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
26235 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: bigint, val: boolean): void {
26236 if(!isWasmInitialized) {
26237 throw new Error("initializeWasm() must be awaited first!");
26239 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
26240 // debug statements here
26242 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
26244 export function UserConfig_get_accept_inbound_channels(this_ptr: bigint): boolean {
26245 if(!isWasmInitialized) {
26246 throw new Error("initializeWasm() must be awaited first!");
26248 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
26249 return nativeResponseValue;
26251 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
26253 export function UserConfig_set_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
26254 if(!isWasmInitialized) {
26255 throw new Error("initializeWasm() must be awaited first!");
26257 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
26258 // debug statements here
26260 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
26262 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: bigint): boolean {
26263 if(!isWasmInitialized) {
26264 throw new Error("initializeWasm() must be awaited first!");
26266 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
26267 return nativeResponseValue;
26269 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
26271 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
26272 if(!isWasmInitialized) {
26273 throw new Error("initializeWasm() must be awaited first!");
26275 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
26276 // debug statements here
26278 // bool UserConfig_get_accept_intercept_htlcs(const struct LDKUserConfig *NONNULL_PTR this_ptr);
26280 export function UserConfig_get_accept_intercept_htlcs(this_ptr: bigint): boolean {
26281 if(!isWasmInitialized) {
26282 throw new Error("initializeWasm() must be awaited first!");
26284 const nativeResponseValue = wasm.TS_UserConfig_get_accept_intercept_htlcs(this_ptr);
26285 return nativeResponseValue;
26287 // void UserConfig_set_accept_intercept_htlcs(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
26289 export function UserConfig_set_accept_intercept_htlcs(this_ptr: bigint, val: boolean): void {
26290 if(!isWasmInitialized) {
26291 throw new Error("initializeWasm() must be awaited first!");
26293 const nativeResponseValue = wasm.TS_UserConfig_set_accept_intercept_htlcs(this_ptr, val);
26294 // debug statements here
26296 // bool UserConfig_get_accept_mpp_keysend(const struct LDKUserConfig *NONNULL_PTR this_ptr);
26298 export function UserConfig_get_accept_mpp_keysend(this_ptr: bigint): boolean {
26299 if(!isWasmInitialized) {
26300 throw new Error("initializeWasm() must be awaited first!");
26302 const nativeResponseValue = wasm.TS_UserConfig_get_accept_mpp_keysend(this_ptr);
26303 return nativeResponseValue;
26305 // void UserConfig_set_accept_mpp_keysend(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
26307 export function UserConfig_set_accept_mpp_keysend(this_ptr: bigint, val: boolean): void {
26308 if(!isWasmInitialized) {
26309 throw new Error("initializeWasm() must be awaited first!");
26311 const nativeResponseValue = wasm.TS_UserConfig_set_accept_mpp_keysend(this_ptr, val);
26312 // debug statements here
26314 // 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);
26316 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 {
26317 if(!isWasmInitialized) {
26318 throw new Error("initializeWasm() must be awaited first!");
26320 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);
26321 return nativeResponseValue;
26323 // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
26325 export function UserConfig_clone_ptr(arg: bigint): bigint {
26326 if(!isWasmInitialized) {
26327 throw new Error("initializeWasm() must be awaited first!");
26329 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
26330 return nativeResponseValue;
26332 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
26334 export function UserConfig_clone(orig: bigint): bigint {
26335 if(!isWasmInitialized) {
26336 throw new Error("initializeWasm() must be awaited first!");
26338 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
26339 return nativeResponseValue;
26341 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
26343 export function UserConfig_default(): bigint {
26344 if(!isWasmInitialized) {
26345 throw new Error("initializeWasm() must be awaited first!");
26347 const nativeResponseValue = wasm.TS_UserConfig_default();
26348 return nativeResponseValue;
26350 // void BestBlock_free(struct LDKBestBlock this_obj);
26352 export function BestBlock_free(this_obj: bigint): void {
26353 if(!isWasmInitialized) {
26354 throw new Error("initializeWasm() must be awaited first!");
26356 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
26357 // debug statements here
26359 // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
26361 export function BestBlock_clone_ptr(arg: bigint): bigint {
26362 if(!isWasmInitialized) {
26363 throw new Error("initializeWasm() must be awaited first!");
26365 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
26366 return nativeResponseValue;
26368 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
26370 export function BestBlock_clone(orig: bigint): bigint {
26371 if(!isWasmInitialized) {
26372 throw new Error("initializeWasm() must be awaited first!");
26374 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
26375 return nativeResponseValue;
26377 // bool BestBlock_eq(const struct LDKBestBlock *NONNULL_PTR a, const struct LDKBestBlock *NONNULL_PTR b);
26379 export function BestBlock_eq(a: bigint, b: bigint): boolean {
26380 if(!isWasmInitialized) {
26381 throw new Error("initializeWasm() must be awaited first!");
26383 const nativeResponseValue = wasm.TS_BestBlock_eq(a, b);
26384 return nativeResponseValue;
26386 // MUST_USE_RES struct LDKBestBlock BestBlock_from_network(enum LDKNetwork network);
26388 export function BestBlock_from_network(network: Network): bigint {
26389 if(!isWasmInitialized) {
26390 throw new Error("initializeWasm() must be awaited first!");
26392 const nativeResponseValue = wasm.TS_BestBlock_from_network(network);
26393 return nativeResponseValue;
26395 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
26397 export function BestBlock_new(block_hash: number, height: number): bigint {
26398 if(!isWasmInitialized) {
26399 throw new Error("initializeWasm() must be awaited first!");
26401 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
26402 return nativeResponseValue;
26404 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
26406 export function BestBlock_block_hash(this_arg: bigint): number {
26407 if(!isWasmInitialized) {
26408 throw new Error("initializeWasm() must be awaited first!");
26410 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
26411 return nativeResponseValue;
26413 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
26415 export function BestBlock_height(this_arg: bigint): number {
26416 if(!isWasmInitialized) {
26417 throw new Error("initializeWasm() must be awaited first!");
26419 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
26420 return nativeResponseValue;
26422 // void Listen_free(struct LDKListen this_ptr);
26424 export function Listen_free(this_ptr: bigint): void {
26425 if(!isWasmInitialized) {
26426 throw new Error("initializeWasm() must be awaited first!");
26428 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
26429 // debug statements here
26431 // void Confirm_free(struct LDKConfirm this_ptr);
26433 export function Confirm_free(this_ptr: bigint): void {
26434 if(!isWasmInitialized) {
26435 throw new Error("initializeWasm() must be awaited first!");
26437 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
26438 // debug statements here
26440 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_clone(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR orig);
26442 export function ChannelMonitorUpdateStatus_clone(orig: bigint): ChannelMonitorUpdateStatus {
26443 if(!isWasmInitialized) {
26444 throw new Error("initializeWasm() must be awaited first!");
26446 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_clone(orig);
26447 return nativeResponseValue;
26449 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_completed(void);
26451 export function ChannelMonitorUpdateStatus_completed(): ChannelMonitorUpdateStatus {
26452 if(!isWasmInitialized) {
26453 throw new Error("initializeWasm() must be awaited first!");
26455 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_completed();
26456 return nativeResponseValue;
26458 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_in_progress(void);
26460 export function ChannelMonitorUpdateStatus_in_progress(): ChannelMonitorUpdateStatus {
26461 if(!isWasmInitialized) {
26462 throw new Error("initializeWasm() must be awaited first!");
26464 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_in_progress();
26465 return nativeResponseValue;
26467 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_unrecoverable_error(void);
26469 export function ChannelMonitorUpdateStatus_unrecoverable_error(): ChannelMonitorUpdateStatus {
26470 if(!isWasmInitialized) {
26471 throw new Error("initializeWasm() must be awaited first!");
26473 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_unrecoverable_error();
26474 return nativeResponseValue;
26476 // bool ChannelMonitorUpdateStatus_eq(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR a, const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR b);
26478 export function ChannelMonitorUpdateStatus_eq(a: bigint, b: bigint): boolean {
26479 if(!isWasmInitialized) {
26480 throw new Error("initializeWasm() must be awaited first!");
26482 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_eq(a, b);
26483 return nativeResponseValue;
26485 // void Watch_free(struct LDKWatch this_ptr);
26487 export function Watch_free(this_ptr: bigint): void {
26488 if(!isWasmInitialized) {
26489 throw new Error("initializeWasm() must be awaited first!");
26491 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
26492 // debug statements here
26494 // void Filter_free(struct LDKFilter this_ptr);
26496 export function Filter_free(this_ptr: bigint): void {
26497 if(!isWasmInitialized) {
26498 throw new Error("initializeWasm() must be awaited first!");
26500 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
26501 // debug statements here
26503 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
26505 export function WatchedOutput_free(this_obj: bigint): void {
26506 if(!isWasmInitialized) {
26507 throw new Error("initializeWasm() must be awaited first!");
26509 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
26510 // debug statements here
26512 // struct LDKCOption_ThirtyTwoBytesZ WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
26514 export function WatchedOutput_get_block_hash(this_ptr: bigint): bigint {
26515 if(!isWasmInitialized) {
26516 throw new Error("initializeWasm() must be awaited first!");
26518 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
26519 return nativeResponseValue;
26521 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
26523 export function WatchedOutput_set_block_hash(this_ptr: bigint, val: bigint): void {
26524 if(!isWasmInitialized) {
26525 throw new Error("initializeWasm() must be awaited first!");
26527 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
26528 // debug statements here
26530 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
26532 export function WatchedOutput_get_outpoint(this_ptr: bigint): bigint {
26533 if(!isWasmInitialized) {
26534 throw new Error("initializeWasm() must be awaited first!");
26536 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
26537 return nativeResponseValue;
26539 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
26541 export function WatchedOutput_set_outpoint(this_ptr: bigint, val: bigint): void {
26542 if(!isWasmInitialized) {
26543 throw new Error("initializeWasm() must be awaited first!");
26545 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
26546 // debug statements here
26548 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
26550 export function WatchedOutput_get_script_pubkey(this_ptr: bigint): number {
26551 if(!isWasmInitialized) {
26552 throw new Error("initializeWasm() must be awaited first!");
26554 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
26555 return nativeResponseValue;
26557 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
26559 export function WatchedOutput_set_script_pubkey(this_ptr: bigint, val: number): void {
26560 if(!isWasmInitialized) {
26561 throw new Error("initializeWasm() must be awaited first!");
26563 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
26564 // debug statements here
26566 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKCOption_ThirtyTwoBytesZ block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
26568 export function WatchedOutput_new(block_hash_arg: bigint, outpoint_arg: bigint, script_pubkey_arg: number): bigint {
26569 if(!isWasmInitialized) {
26570 throw new Error("initializeWasm() must be awaited first!");
26572 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
26573 return nativeResponseValue;
26575 // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
26577 export function WatchedOutput_clone_ptr(arg: bigint): bigint {
26578 if(!isWasmInitialized) {
26579 throw new Error("initializeWasm() must be awaited first!");
26581 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
26582 return nativeResponseValue;
26584 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
26586 export function WatchedOutput_clone(orig: bigint): bigint {
26587 if(!isWasmInitialized) {
26588 throw new Error("initializeWasm() must be awaited first!");
26590 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
26591 return nativeResponseValue;
26593 // bool WatchedOutput_eq(const struct LDKWatchedOutput *NONNULL_PTR a, const struct LDKWatchedOutput *NONNULL_PTR b);
26595 export function WatchedOutput_eq(a: bigint, b: bigint): boolean {
26596 if(!isWasmInitialized) {
26597 throw new Error("initializeWasm() must be awaited first!");
26599 const nativeResponseValue = wasm.TS_WatchedOutput_eq(a, b);
26600 return nativeResponseValue;
26602 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
26604 export function WatchedOutput_hash(o: bigint): bigint {
26605 if(!isWasmInitialized) {
26606 throw new Error("initializeWasm() must be awaited first!");
26608 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
26609 return nativeResponseValue;
26611 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
26613 export function BroadcasterInterface_free(this_ptr: bigint): void {
26614 if(!isWasmInitialized) {
26615 throw new Error("initializeWasm() must be awaited first!");
26617 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
26618 // debug statements here
26620 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
26622 export function ConfirmationTarget_clone(orig: bigint): ConfirmationTarget {
26623 if(!isWasmInitialized) {
26624 throw new Error("initializeWasm() must be awaited first!");
26626 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
26627 return nativeResponseValue;
26629 // enum LDKConfirmationTarget ConfirmationTarget_on_chain_sweep(void);
26631 export function ConfirmationTarget_on_chain_sweep(): ConfirmationTarget {
26632 if(!isWasmInitialized) {
26633 throw new Error("initializeWasm() must be awaited first!");
26635 const nativeResponseValue = wasm.TS_ConfirmationTarget_on_chain_sweep();
26636 return nativeResponseValue;
26638 // enum LDKConfirmationTarget ConfirmationTarget_max_allowed_non_anchor_channel_remote_fee(void);
26640 export function ConfirmationTarget_max_allowed_non_anchor_channel_remote_fee(): ConfirmationTarget {
26641 if(!isWasmInitialized) {
26642 throw new Error("initializeWasm() must be awaited first!");
26644 const nativeResponseValue = wasm.TS_ConfirmationTarget_max_allowed_non_anchor_channel_remote_fee();
26645 return nativeResponseValue;
26647 // enum LDKConfirmationTarget ConfirmationTarget_min_allowed_anchor_channel_remote_fee(void);
26649 export function ConfirmationTarget_min_allowed_anchor_channel_remote_fee(): ConfirmationTarget {
26650 if(!isWasmInitialized) {
26651 throw new Error("initializeWasm() must be awaited first!");
26653 const nativeResponseValue = wasm.TS_ConfirmationTarget_min_allowed_anchor_channel_remote_fee();
26654 return nativeResponseValue;
26656 // enum LDKConfirmationTarget ConfirmationTarget_min_allowed_non_anchor_channel_remote_fee(void);
26658 export function ConfirmationTarget_min_allowed_non_anchor_channel_remote_fee(): ConfirmationTarget {
26659 if(!isWasmInitialized) {
26660 throw new Error("initializeWasm() must be awaited first!");
26662 const nativeResponseValue = wasm.TS_ConfirmationTarget_min_allowed_non_anchor_channel_remote_fee();
26663 return nativeResponseValue;
26665 // enum LDKConfirmationTarget ConfirmationTarget_anchor_channel_fee(void);
26667 export function ConfirmationTarget_anchor_channel_fee(): ConfirmationTarget {
26668 if(!isWasmInitialized) {
26669 throw new Error("initializeWasm() must be awaited first!");
26671 const nativeResponseValue = wasm.TS_ConfirmationTarget_anchor_channel_fee();
26672 return nativeResponseValue;
26674 // enum LDKConfirmationTarget ConfirmationTarget_non_anchor_channel_fee(void);
26676 export function ConfirmationTarget_non_anchor_channel_fee(): ConfirmationTarget {
26677 if(!isWasmInitialized) {
26678 throw new Error("initializeWasm() must be awaited first!");
26680 const nativeResponseValue = wasm.TS_ConfirmationTarget_non_anchor_channel_fee();
26681 return nativeResponseValue;
26683 // enum LDKConfirmationTarget ConfirmationTarget_channel_close_minimum(void);
26685 export function ConfirmationTarget_channel_close_minimum(): ConfirmationTarget {
26686 if(!isWasmInitialized) {
26687 throw new Error("initializeWasm() must be awaited first!");
26689 const nativeResponseValue = wasm.TS_ConfirmationTarget_channel_close_minimum();
26690 return nativeResponseValue;
26692 // uint64_t ConfirmationTarget_hash(const enum LDKConfirmationTarget *NONNULL_PTR o);
26694 export function ConfirmationTarget_hash(o: bigint): bigint {
26695 if(!isWasmInitialized) {
26696 throw new Error("initializeWasm() must be awaited first!");
26698 const nativeResponseValue = wasm.TS_ConfirmationTarget_hash(o);
26699 return nativeResponseValue;
26701 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
26703 export function ConfirmationTarget_eq(a: bigint, b: bigint): boolean {
26704 if(!isWasmInitialized) {
26705 throw new Error("initializeWasm() must be awaited first!");
26707 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
26708 return nativeResponseValue;
26710 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
26712 export function FeeEstimator_free(this_ptr: bigint): void {
26713 if(!isWasmInitialized) {
26714 throw new Error("initializeWasm() must be awaited first!");
26716 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
26717 // debug statements here
26719 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
26721 export function MonitorUpdateId_free(this_obj: bigint): void {
26722 if(!isWasmInitialized) {
26723 throw new Error("initializeWasm() must be awaited first!");
26725 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
26726 // debug statements here
26728 // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
26730 export function MonitorUpdateId_clone_ptr(arg: bigint): bigint {
26731 if(!isWasmInitialized) {
26732 throw new Error("initializeWasm() must be awaited first!");
26734 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
26735 return nativeResponseValue;
26737 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
26739 export function MonitorUpdateId_clone(orig: bigint): bigint {
26740 if(!isWasmInitialized) {
26741 throw new Error("initializeWasm() must be awaited first!");
26743 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
26744 return nativeResponseValue;
26746 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
26748 export function MonitorUpdateId_hash(o: bigint): bigint {
26749 if(!isWasmInitialized) {
26750 throw new Error("initializeWasm() must be awaited first!");
26752 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
26753 return nativeResponseValue;
26755 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
26757 export function MonitorUpdateId_eq(a: bigint, b: bigint): boolean {
26758 if(!isWasmInitialized) {
26759 throw new Error("initializeWasm() must be awaited first!");
26761 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
26762 return nativeResponseValue;
26764 // void Persist_free(struct LDKPersist this_ptr);
26766 export function Persist_free(this_ptr: bigint): void {
26767 if(!isWasmInitialized) {
26768 throw new Error("initializeWasm() must be awaited first!");
26770 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
26771 // debug statements here
26773 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
26775 export function LockedChannelMonitor_free(this_obj: bigint): void {
26776 if(!isWasmInitialized) {
26777 throw new Error("initializeWasm() must be awaited first!");
26779 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
26780 // debug statements here
26782 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
26784 export function ChainMonitor_free(this_obj: bigint): void {
26785 if(!isWasmInitialized) {
26786 throw new Error("initializeWasm() must be awaited first!");
26788 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
26789 // debug statements here
26791 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
26793 export function ChainMonitor_new(chain_source: bigint, broadcaster: bigint, logger: bigint, feeest: bigint, persister: bigint): bigint {
26794 if(!isWasmInitialized) {
26795 throw new Error("initializeWasm() must be awaited first!");
26797 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
26798 return nativeResponseValue;
26800 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
26802 export function ChainMonitor_get_claimable_balances(this_arg: bigint, ignored_channels: number): number {
26803 if(!isWasmInitialized) {
26804 throw new Error("initializeWasm() must be awaited first!");
26806 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
26807 return nativeResponseValue;
26809 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
26811 export function ChainMonitor_get_monitor(this_arg: bigint, funding_txo: bigint): bigint {
26812 if(!isWasmInitialized) {
26813 throw new Error("initializeWasm() must be awaited first!");
26815 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
26816 return nativeResponseValue;
26818 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26820 export function ChainMonitor_list_monitors(this_arg: bigint): number {
26821 if(!isWasmInitialized) {
26822 throw new Error("initializeWasm() must be awaited first!");
26824 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
26825 return nativeResponseValue;
26827 // MUST_USE_RES struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ChainMonitor_list_pending_monitor_updates(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26829 export function ChainMonitor_list_pending_monitor_updates(this_arg: bigint): number {
26830 if(!isWasmInitialized) {
26831 throw new Error("initializeWasm() must be awaited first!");
26833 const nativeResponseValue = wasm.TS_ChainMonitor_list_pending_monitor_updates(this_arg);
26834 return nativeResponseValue;
26836 // 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);
26838 export function ChainMonitor_channel_monitor_updated(this_arg: bigint, funding_txo: bigint, completed_update_id: bigint): bigint {
26839 if(!isWasmInitialized) {
26840 throw new Error("initializeWasm() must be awaited first!");
26842 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
26843 return nativeResponseValue;
26845 // MUST_USE_RES struct LDKFuture ChainMonitor_get_update_future(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26847 export function ChainMonitor_get_update_future(this_arg: bigint): bigint {
26848 if(!isWasmInitialized) {
26849 throw new Error("initializeWasm() must be awaited first!");
26851 const nativeResponseValue = wasm.TS_ChainMonitor_get_update_future(this_arg);
26852 return nativeResponseValue;
26854 // void ChainMonitor_rebroadcast_pending_claims(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26856 export function ChainMonitor_rebroadcast_pending_claims(this_arg: bigint): void {
26857 if(!isWasmInitialized) {
26858 throw new Error("initializeWasm() must be awaited first!");
26860 const nativeResponseValue = wasm.TS_ChainMonitor_rebroadcast_pending_claims(this_arg);
26861 // debug statements here
26863 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26865 export function ChainMonitor_as_Listen(this_arg: bigint): bigint {
26866 if(!isWasmInitialized) {
26867 throw new Error("initializeWasm() must be awaited first!");
26869 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
26870 return nativeResponseValue;
26872 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26874 export function ChainMonitor_as_Confirm(this_arg: bigint): bigint {
26875 if(!isWasmInitialized) {
26876 throw new Error("initializeWasm() must be awaited first!");
26878 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
26879 return nativeResponseValue;
26881 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26883 export function ChainMonitor_as_Watch(this_arg: bigint): bigint {
26884 if(!isWasmInitialized) {
26885 throw new Error("initializeWasm() must be awaited first!");
26887 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
26888 return nativeResponseValue;
26890 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
26892 export function ChainMonitor_as_EventsProvider(this_arg: bigint): bigint {
26893 if(!isWasmInitialized) {
26894 throw new Error("initializeWasm() must be awaited first!");
26896 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
26897 return nativeResponseValue;
26899 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
26901 export function ChannelMonitorUpdate_free(this_obj: bigint): void {
26902 if(!isWasmInitialized) {
26903 throw new Error("initializeWasm() must be awaited first!");
26905 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
26906 // debug statements here
26908 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
26910 export function ChannelMonitorUpdate_get_update_id(this_ptr: bigint): bigint {
26911 if(!isWasmInitialized) {
26912 throw new Error("initializeWasm() must be awaited first!");
26914 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
26915 return nativeResponseValue;
26917 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
26919 export function ChannelMonitorUpdate_set_update_id(this_ptr: bigint, val: bigint): void {
26920 if(!isWasmInitialized) {
26921 throw new Error("initializeWasm() must be awaited first!");
26923 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
26924 // debug statements here
26926 // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
26928 export function ChannelMonitorUpdate_clone_ptr(arg: bigint): bigint {
26929 if(!isWasmInitialized) {
26930 throw new Error("initializeWasm() must be awaited first!");
26932 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
26933 return nativeResponseValue;
26935 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
26937 export function ChannelMonitorUpdate_clone(orig: bigint): bigint {
26938 if(!isWasmInitialized) {
26939 throw new Error("initializeWasm() must be awaited first!");
26941 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
26942 return nativeResponseValue;
26944 // bool ChannelMonitorUpdate_eq(const struct LDKChannelMonitorUpdate *NONNULL_PTR a, const struct LDKChannelMonitorUpdate *NONNULL_PTR b);
26946 export function ChannelMonitorUpdate_eq(a: bigint, b: bigint): boolean {
26947 if(!isWasmInitialized) {
26948 throw new Error("initializeWasm() must be awaited first!");
26950 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_eq(a, b);
26951 return nativeResponseValue;
26953 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
26955 export function ChannelMonitorUpdate_write(obj: bigint): number {
26956 if(!isWasmInitialized) {
26957 throw new Error("initializeWasm() must be awaited first!");
26959 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
26960 return nativeResponseValue;
26962 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
26964 export function ChannelMonitorUpdate_read(ser: number): bigint {
26965 if(!isWasmInitialized) {
26966 throw new Error("initializeWasm() must be awaited first!");
26968 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
26969 return nativeResponseValue;
26971 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
26973 export function MonitorEvent_free(this_ptr: bigint): void {
26974 if(!isWasmInitialized) {
26975 throw new Error("initializeWasm() must be awaited first!");
26977 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
26978 // debug statements here
26980 // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
26982 export function MonitorEvent_clone_ptr(arg: bigint): bigint {
26983 if(!isWasmInitialized) {
26984 throw new Error("initializeWasm() must be awaited first!");
26986 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
26987 return nativeResponseValue;
26989 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
26991 export function MonitorEvent_clone(orig: bigint): bigint {
26992 if(!isWasmInitialized) {
26993 throw new Error("initializeWasm() must be awaited first!");
26995 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
26996 return nativeResponseValue;
26998 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
27000 export function MonitorEvent_htlcevent(a: bigint): bigint {
27001 if(!isWasmInitialized) {
27002 throw new Error("initializeWasm() must be awaited first!");
27004 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
27005 return nativeResponseValue;
27007 // struct LDKMonitorEvent MonitorEvent_holder_force_closed(struct LDKOutPoint a);
27009 export function MonitorEvent_holder_force_closed(a: bigint): bigint {
27010 if(!isWasmInitialized) {
27011 throw new Error("initializeWasm() must be awaited first!");
27013 const nativeResponseValue = wasm.TS_MonitorEvent_holder_force_closed(a);
27014 return nativeResponseValue;
27016 // struct LDKMonitorEvent MonitorEvent_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
27018 export function MonitorEvent_completed(funding_txo: bigint, monitor_update_id: bigint): bigint {
27019 if(!isWasmInitialized) {
27020 throw new Error("initializeWasm() must be awaited first!");
27022 const nativeResponseValue = wasm.TS_MonitorEvent_completed(funding_txo, monitor_update_id);
27023 return nativeResponseValue;
27025 // bool MonitorEvent_eq(const struct LDKMonitorEvent *NONNULL_PTR a, const struct LDKMonitorEvent *NONNULL_PTR b);
27027 export function MonitorEvent_eq(a: bigint, b: bigint): boolean {
27028 if(!isWasmInitialized) {
27029 throw new Error("initializeWasm() must be awaited first!");
27031 const nativeResponseValue = wasm.TS_MonitorEvent_eq(a, b);
27032 return nativeResponseValue;
27034 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
27036 export function MonitorEvent_write(obj: bigint): number {
27037 if(!isWasmInitialized) {
27038 throw new Error("initializeWasm() must be awaited first!");
27040 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
27041 return nativeResponseValue;
27043 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
27045 export function MonitorEvent_read(ser: number): bigint {
27046 if(!isWasmInitialized) {
27047 throw new Error("initializeWasm() must be awaited first!");
27049 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
27050 return nativeResponseValue;
27052 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
27054 export function HTLCUpdate_free(this_obj: bigint): void {
27055 if(!isWasmInitialized) {
27056 throw new Error("initializeWasm() must be awaited first!");
27058 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
27059 // debug statements here
27061 // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
27063 export function HTLCUpdate_clone_ptr(arg: bigint): bigint {
27064 if(!isWasmInitialized) {
27065 throw new Error("initializeWasm() must be awaited first!");
27067 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
27068 return nativeResponseValue;
27070 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
27072 export function HTLCUpdate_clone(orig: bigint): bigint {
27073 if(!isWasmInitialized) {
27074 throw new Error("initializeWasm() must be awaited first!");
27076 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
27077 return nativeResponseValue;
27079 // bool HTLCUpdate_eq(const struct LDKHTLCUpdate *NONNULL_PTR a, const struct LDKHTLCUpdate *NONNULL_PTR b);
27081 export function HTLCUpdate_eq(a: bigint, b: bigint): boolean {
27082 if(!isWasmInitialized) {
27083 throw new Error("initializeWasm() must be awaited first!");
27085 const nativeResponseValue = wasm.TS_HTLCUpdate_eq(a, b);
27086 return nativeResponseValue;
27088 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
27090 export function HTLCUpdate_write(obj: bigint): number {
27091 if(!isWasmInitialized) {
27092 throw new Error("initializeWasm() must be awaited first!");
27094 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
27095 return nativeResponseValue;
27097 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
27099 export function HTLCUpdate_read(ser: number): bigint {
27100 if(!isWasmInitialized) {
27101 throw new Error("initializeWasm() must be awaited first!");
27103 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
27104 return nativeResponseValue;
27106 // void Balance_free(struct LDKBalance this_ptr);
27108 export function Balance_free(this_ptr: bigint): void {
27109 if(!isWasmInitialized) {
27110 throw new Error("initializeWasm() must be awaited first!");
27112 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
27113 // debug statements here
27115 // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
27117 export function Balance_clone_ptr(arg: bigint): bigint {
27118 if(!isWasmInitialized) {
27119 throw new Error("initializeWasm() must be awaited first!");
27121 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
27122 return nativeResponseValue;
27124 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
27126 export function Balance_clone(orig: bigint): bigint {
27127 if(!isWasmInitialized) {
27128 throw new Error("initializeWasm() must be awaited first!");
27130 const nativeResponseValue = wasm.TS_Balance_clone(orig);
27131 return nativeResponseValue;
27133 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t amount_satoshis);
27135 export function Balance_claimable_on_channel_close(amount_satoshis: bigint): bigint {
27136 if(!isWasmInitialized) {
27137 throw new Error("initializeWasm() must be awaited first!");
27139 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(amount_satoshis);
27140 return nativeResponseValue;
27142 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t amount_satoshis, uint32_t confirmation_height);
27144 export function Balance_claimable_awaiting_confirmations(amount_satoshis: bigint, confirmation_height: number): bigint {
27145 if(!isWasmInitialized) {
27146 throw new Error("initializeWasm() must be awaited first!");
27148 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(amount_satoshis, confirmation_height);
27149 return nativeResponseValue;
27151 // struct LDKBalance Balance_contentious_claimable(uint64_t amount_satoshis, uint32_t timeout_height, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_preimage);
27153 export function Balance_contentious_claimable(amount_satoshis: bigint, timeout_height: number, payment_hash: number, payment_preimage: number): bigint {
27154 if(!isWasmInitialized) {
27155 throw new Error("initializeWasm() must be awaited first!");
27157 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(amount_satoshis, timeout_height, payment_hash, payment_preimage);
27158 return nativeResponseValue;
27160 // struct LDKBalance Balance_maybe_timeout_claimable_htlc(uint64_t amount_satoshis, uint32_t claimable_height, struct LDKThirtyTwoBytes payment_hash);
27162 export function Balance_maybe_timeout_claimable_htlc(amount_satoshis: bigint, claimable_height: number, payment_hash: number): bigint {
27163 if(!isWasmInitialized) {
27164 throw new Error("initializeWasm() must be awaited first!");
27166 const nativeResponseValue = wasm.TS_Balance_maybe_timeout_claimable_htlc(amount_satoshis, claimable_height, payment_hash);
27167 return nativeResponseValue;
27169 // struct LDKBalance Balance_maybe_preimage_claimable_htlc(uint64_t amount_satoshis, uint32_t expiry_height, struct LDKThirtyTwoBytes payment_hash);
27171 export function Balance_maybe_preimage_claimable_htlc(amount_satoshis: bigint, expiry_height: number, payment_hash: number): bigint {
27172 if(!isWasmInitialized) {
27173 throw new Error("initializeWasm() must be awaited first!");
27175 const nativeResponseValue = wasm.TS_Balance_maybe_preimage_claimable_htlc(amount_satoshis, expiry_height, payment_hash);
27176 return nativeResponseValue;
27178 // struct LDKBalance Balance_counterparty_revoked_output_claimable(uint64_t amount_satoshis);
27180 export function Balance_counterparty_revoked_output_claimable(amount_satoshis: bigint): bigint {
27181 if(!isWasmInitialized) {
27182 throw new Error("initializeWasm() must be awaited first!");
27184 const nativeResponseValue = wasm.TS_Balance_counterparty_revoked_output_claimable(amount_satoshis);
27185 return nativeResponseValue;
27187 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
27189 export function Balance_eq(a: bigint, b: bigint): boolean {
27190 if(!isWasmInitialized) {
27191 throw new Error("initializeWasm() must be awaited first!");
27193 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
27194 return nativeResponseValue;
27196 // MUST_USE_RES uint64_t Balance_claimable_amount_satoshis(const struct LDKBalance *NONNULL_PTR this_arg);
27198 export function Balance_claimable_amount_satoshis(this_arg: bigint): bigint {
27199 if(!isWasmInitialized) {
27200 throw new Error("initializeWasm() must be awaited first!");
27202 const nativeResponseValue = wasm.TS_Balance_claimable_amount_satoshis(this_arg);
27203 return nativeResponseValue;
27205 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
27207 export function ChannelMonitor_free(this_obj: bigint): void {
27208 if(!isWasmInitialized) {
27209 throw new Error("initializeWasm() must be awaited first!");
27211 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
27212 // debug statements here
27214 // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
27216 export function ChannelMonitor_clone_ptr(arg: bigint): bigint {
27217 if(!isWasmInitialized) {
27218 throw new Error("initializeWasm() must be awaited first!");
27220 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
27221 return nativeResponseValue;
27223 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
27225 export function ChannelMonitor_clone(orig: bigint): bigint {
27226 if(!isWasmInitialized) {
27227 throw new Error("initializeWasm() must be awaited first!");
27229 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
27230 return nativeResponseValue;
27232 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
27234 export function ChannelMonitor_write(obj: bigint): number {
27235 if(!isWasmInitialized) {
27236 throw new Error("initializeWasm() must be awaited first!");
27238 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
27239 return nativeResponseValue;
27241 // 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);
27243 export function ChannelMonitor_update_monitor(this_arg: bigint, updates: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): bigint {
27244 if(!isWasmInitialized) {
27245 throw new Error("initializeWasm() must be awaited first!");
27247 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
27248 return nativeResponseValue;
27250 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
27252 export function ChannelMonitor_get_latest_update_id(this_arg: bigint): bigint {
27253 if(!isWasmInitialized) {
27254 throw new Error("initializeWasm() must be awaited first!");
27256 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
27257 return nativeResponseValue;
27259 // MUST_USE_RES struct LDKC2Tuple_OutPointCVec_u8ZZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
27261 export function ChannelMonitor_get_funding_txo(this_arg: bigint): bigint {
27262 if(!isWasmInitialized) {
27263 throw new Error("initializeWasm() must be awaited first!");
27265 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
27266 return nativeResponseValue;
27268 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
27270 export function ChannelMonitor_get_outputs_to_watch(this_arg: bigint): number {
27271 if(!isWasmInitialized) {
27272 throw new Error("initializeWasm() must be awaited first!");
27274 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
27275 return nativeResponseValue;
27277 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
27279 export function ChannelMonitor_load_outputs_to_watch(this_arg: bigint, filter: bigint): void {
27280 if(!isWasmInitialized) {
27281 throw new Error("initializeWasm() must be awaited first!");
27283 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
27284 // debug statements here
27286 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
27288 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: bigint): number {
27289 if(!isWasmInitialized) {
27290 throw new Error("initializeWasm() must be awaited first!");
27292 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
27293 return nativeResponseValue;
27295 // void ChannelMonitor_process_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKEventHandler *NONNULL_PTR handler);
27297 export function ChannelMonitor_process_pending_events(this_arg: bigint, handler: bigint): void {
27298 if(!isWasmInitialized) {
27299 throw new Error("initializeWasm() must be awaited first!");
27301 const nativeResponseValue = wasm.TS_ChannelMonitor_process_pending_events(this_arg, handler);
27302 // debug statements here
27304 // MUST_USE_RES struct LDKCommitmentTransaction ChannelMonitor_initial_counterparty_commitment_tx(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
27306 export function ChannelMonitor_initial_counterparty_commitment_tx(this_arg: bigint): bigint {
27307 if(!isWasmInitialized) {
27308 throw new Error("initializeWasm() must be awaited first!");
27310 const nativeResponseValue = wasm.TS_ChannelMonitor_initial_counterparty_commitment_tx(this_arg);
27311 return nativeResponseValue;
27313 // 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);
27315 export function ChannelMonitor_counterparty_commitment_txs_from_update(this_arg: bigint, update: bigint): number {
27316 if(!isWasmInitialized) {
27317 throw new Error("initializeWasm() must be awaited first!");
27319 const nativeResponseValue = wasm.TS_ChannelMonitor_counterparty_commitment_txs_from_update(this_arg, update);
27320 return nativeResponseValue;
27322 // 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);
27324 export function ChannelMonitor_sign_to_local_justice_tx(this_arg: bigint, justice_tx: number, input_idx: number, value: bigint, commitment_number: bigint): bigint {
27325 if(!isWasmInitialized) {
27326 throw new Error("initializeWasm() must be awaited first!");
27328 const nativeResponseValue = wasm.TS_ChannelMonitor_sign_to_local_justice_tx(this_arg, justice_tx, input_idx, value, commitment_number);
27329 return nativeResponseValue;
27331 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
27333 export function ChannelMonitor_get_counterparty_node_id(this_arg: bigint): number {
27334 if(!isWasmInitialized) {
27335 throw new Error("initializeWasm() must be awaited first!");
27337 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
27338 return nativeResponseValue;
27340 // MUST_USE_RES struct LDKCVec_TransactionZ ChannelMonitor_get_latest_holder_commitment_txn(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger);
27342 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: bigint, logger: bigint): number {
27343 if(!isWasmInitialized) {
27344 throw new Error("initializeWasm() must be awaited first!");
27346 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
27347 return nativeResponseValue;
27349 // 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, struct LDKLogger logger);
27351 export function ChannelMonitor_block_connected(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
27352 if(!isWasmInitialized) {
27353 throw new Error("initializeWasm() must be awaited first!");
27355 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
27356 return nativeResponseValue;
27358 // void ChannelMonitor_block_disconnected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
27360 export function ChannelMonitor_block_disconnected(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
27361 if(!isWasmInitialized) {
27362 throw new Error("initializeWasm() must be awaited first!");
27364 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
27365 // debug statements here
27367 // 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, struct LDKLogger logger);
27369 export function ChannelMonitor_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
27370 if(!isWasmInitialized) {
27371 throw new Error("initializeWasm() must be awaited first!");
27373 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
27374 return nativeResponseValue;
27376 // void ChannelMonitor_transaction_unconfirmed(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
27378 export function ChannelMonitor_transaction_unconfirmed(this_arg: bigint, txid: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
27379 if(!isWasmInitialized) {
27380 throw new Error("initializeWasm() must be awaited first!");
27382 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
27383 // debug statements here
27385 // 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, struct LDKLogger logger);
27387 export function ChannelMonitor_best_block_updated(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
27388 if(!isWasmInitialized) {
27389 throw new Error("initializeWasm() must be awaited first!");
27391 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
27392 return nativeResponseValue;
27394 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
27396 export function ChannelMonitor_get_relevant_txids(this_arg: bigint): number {
27397 if(!isWasmInitialized) {
27398 throw new Error("initializeWasm() must be awaited first!");
27400 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
27401 return nativeResponseValue;
27403 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
27405 export function ChannelMonitor_current_best_block(this_arg: bigint): bigint {
27406 if(!isWasmInitialized) {
27407 throw new Error("initializeWasm() must be awaited first!");
27409 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
27410 return nativeResponseValue;
27412 // void ChannelMonitor_rebroadcast_pending_claims(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
27414 export function ChannelMonitor_rebroadcast_pending_claims(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
27415 if(!isWasmInitialized) {
27416 throw new Error("initializeWasm() must be awaited first!");
27418 const nativeResponseValue = wasm.TS_ChannelMonitor_rebroadcast_pending_claims(this_arg, broadcaster, fee_estimator, logger);
27419 // debug statements here
27421 // MUST_USE_RES struct LDKCVec_SpendableOutputDescriptorZ ChannelMonitor_get_spendable_outputs(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKTransaction tx, uint32_t confirmation_height);
27423 export function ChannelMonitor_get_spendable_outputs(this_arg: bigint, tx: number, confirmation_height: number): number {
27424 if(!isWasmInitialized) {
27425 throw new Error("initializeWasm() must be awaited first!");
27427 const nativeResponseValue = wasm.TS_ChannelMonitor_get_spendable_outputs(this_arg, tx, confirmation_height);
27428 return nativeResponseValue;
27430 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
27432 export function ChannelMonitor_get_claimable_balances(this_arg: bigint): number {
27433 if(!isWasmInitialized) {
27434 throw new Error("initializeWasm() must be awaited first!");
27436 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
27437 return nativeResponseValue;
27439 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKEntropySource *NONNULL_PTR arg_a, const struct LDKSignerProvider *NONNULL_PTR arg_b);
27441 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(ser: number, arg_a: bigint, arg_b: bigint): bigint {
27442 if(!isWasmInitialized) {
27443 throw new Error("initializeWasm() must be awaited first!");
27445 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(ser, arg_a, arg_b);
27446 return nativeResponseValue;
27448 // void OutPoint_free(struct LDKOutPoint this_obj);
27450 export function OutPoint_free(this_obj: bigint): void {
27451 if(!isWasmInitialized) {
27452 throw new Error("initializeWasm() must be awaited first!");
27454 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
27455 // debug statements here
27457 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
27459 export function OutPoint_get_txid(this_ptr: bigint): number {
27460 if(!isWasmInitialized) {
27461 throw new Error("initializeWasm() must be awaited first!");
27463 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
27464 return nativeResponseValue;
27466 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27468 export function OutPoint_set_txid(this_ptr: bigint, val: number): void {
27469 if(!isWasmInitialized) {
27470 throw new Error("initializeWasm() must be awaited first!");
27472 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
27473 // debug statements here
27475 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
27477 export function OutPoint_get_index(this_ptr: bigint): number {
27478 if(!isWasmInitialized) {
27479 throw new Error("initializeWasm() must be awaited first!");
27481 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
27482 return nativeResponseValue;
27484 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
27486 export function OutPoint_set_index(this_ptr: bigint, val: number): void {
27487 if(!isWasmInitialized) {
27488 throw new Error("initializeWasm() must be awaited first!");
27490 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
27491 // debug statements here
27493 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
27495 export function OutPoint_new(txid_arg: number, index_arg: number): bigint {
27496 if(!isWasmInitialized) {
27497 throw new Error("initializeWasm() must be awaited first!");
27499 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
27500 return nativeResponseValue;
27502 // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
27504 export function OutPoint_clone_ptr(arg: bigint): bigint {
27505 if(!isWasmInitialized) {
27506 throw new Error("initializeWasm() must be awaited first!");
27508 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
27509 return nativeResponseValue;
27511 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
27513 export function OutPoint_clone(orig: bigint): bigint {
27514 if(!isWasmInitialized) {
27515 throw new Error("initializeWasm() must be awaited first!");
27517 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
27518 return nativeResponseValue;
27520 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
27522 export function OutPoint_eq(a: bigint, b: bigint): boolean {
27523 if(!isWasmInitialized) {
27524 throw new Error("initializeWasm() must be awaited first!");
27526 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
27527 return nativeResponseValue;
27529 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
27531 export function OutPoint_hash(o: bigint): bigint {
27532 if(!isWasmInitialized) {
27533 throw new Error("initializeWasm() must be awaited first!");
27535 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
27536 return nativeResponseValue;
27538 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
27540 export function OutPoint_to_channel_id(this_arg: bigint): number {
27541 if(!isWasmInitialized) {
27542 throw new Error("initializeWasm() must be awaited first!");
27544 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
27545 return nativeResponseValue;
27547 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
27549 export function OutPoint_write(obj: bigint): number {
27550 if(!isWasmInitialized) {
27551 throw new Error("initializeWasm() must be awaited first!");
27553 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
27554 return nativeResponseValue;
27556 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
27558 export function OutPoint_read(ser: number): bigint {
27559 if(!isWasmInitialized) {
27560 throw new Error("initializeWasm() must be awaited first!");
27562 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
27563 return nativeResponseValue;
27565 // void FailureCode_free(struct LDKFailureCode this_ptr);
27567 export function FailureCode_free(this_ptr: bigint): void {
27568 if(!isWasmInitialized) {
27569 throw new Error("initializeWasm() must be awaited first!");
27571 const nativeResponseValue = wasm.TS_FailureCode_free(this_ptr);
27572 // debug statements here
27574 // uint64_t FailureCode_clone_ptr(LDKFailureCode *NONNULL_PTR arg);
27576 export function FailureCode_clone_ptr(arg: bigint): bigint {
27577 if(!isWasmInitialized) {
27578 throw new Error("initializeWasm() must be awaited first!");
27580 const nativeResponseValue = wasm.TS_FailureCode_clone_ptr(arg);
27581 return nativeResponseValue;
27583 // struct LDKFailureCode FailureCode_clone(const struct LDKFailureCode *NONNULL_PTR orig);
27585 export function FailureCode_clone(orig: bigint): bigint {
27586 if(!isWasmInitialized) {
27587 throw new Error("initializeWasm() must be awaited first!");
27589 const nativeResponseValue = wasm.TS_FailureCode_clone(orig);
27590 return nativeResponseValue;
27592 // struct LDKFailureCode FailureCode_temporary_node_failure(void);
27594 export function FailureCode_temporary_node_failure(): bigint {
27595 if(!isWasmInitialized) {
27596 throw new Error("initializeWasm() must be awaited first!");
27598 const nativeResponseValue = wasm.TS_FailureCode_temporary_node_failure();
27599 return nativeResponseValue;
27601 // struct LDKFailureCode FailureCode_required_node_feature_missing(void);
27603 export function FailureCode_required_node_feature_missing(): bigint {
27604 if(!isWasmInitialized) {
27605 throw new Error("initializeWasm() must be awaited first!");
27607 const nativeResponseValue = wasm.TS_FailureCode_required_node_feature_missing();
27608 return nativeResponseValue;
27610 // struct LDKFailureCode FailureCode_incorrect_or_unknown_payment_details(void);
27612 export function FailureCode_incorrect_or_unknown_payment_details(): bigint {
27613 if(!isWasmInitialized) {
27614 throw new Error("initializeWasm() must be awaited first!");
27616 const nativeResponseValue = wasm.TS_FailureCode_incorrect_or_unknown_payment_details();
27617 return nativeResponseValue;
27619 // struct LDKFailureCode FailureCode_invalid_onion_payload(struct LDKCOption_C2Tuple_u64u16ZZ a);
27621 export function FailureCode_invalid_onion_payload(a: bigint): bigint {
27622 if(!isWasmInitialized) {
27623 throw new Error("initializeWasm() must be awaited first!");
27625 const nativeResponseValue = wasm.TS_FailureCode_invalid_onion_payload(a);
27626 return nativeResponseValue;
27628 // void ChannelManager_free(struct LDKChannelManager this_obj);
27630 export function ChannelManager_free(this_obj: bigint): void {
27631 if(!isWasmInitialized) {
27632 throw new Error("initializeWasm() must be awaited first!");
27634 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
27635 // debug statements here
27637 // void ChainParameters_free(struct LDKChainParameters this_obj);
27639 export function ChainParameters_free(this_obj: bigint): void {
27640 if(!isWasmInitialized) {
27641 throw new Error("initializeWasm() must be awaited first!");
27643 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
27644 // debug statements here
27646 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
27648 export function ChainParameters_get_network(this_ptr: bigint): Network {
27649 if(!isWasmInitialized) {
27650 throw new Error("initializeWasm() must be awaited first!");
27652 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
27653 return nativeResponseValue;
27655 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
27657 export function ChainParameters_set_network(this_ptr: bigint, val: Network): void {
27658 if(!isWasmInitialized) {
27659 throw new Error("initializeWasm() must be awaited first!");
27661 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
27662 // debug statements here
27664 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
27666 export function ChainParameters_get_best_block(this_ptr: bigint): bigint {
27667 if(!isWasmInitialized) {
27668 throw new Error("initializeWasm() must be awaited first!");
27670 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
27671 return nativeResponseValue;
27673 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
27675 export function ChainParameters_set_best_block(this_ptr: bigint, val: bigint): void {
27676 if(!isWasmInitialized) {
27677 throw new Error("initializeWasm() must be awaited first!");
27679 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
27680 // debug statements here
27682 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
27684 export function ChainParameters_new(network_arg: Network, best_block_arg: bigint): bigint {
27685 if(!isWasmInitialized) {
27686 throw new Error("initializeWasm() must be awaited first!");
27688 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
27689 return nativeResponseValue;
27691 // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
27693 export function ChainParameters_clone_ptr(arg: bigint): bigint {
27694 if(!isWasmInitialized) {
27695 throw new Error("initializeWasm() must be awaited first!");
27697 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
27698 return nativeResponseValue;
27700 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
27702 export function ChainParameters_clone(orig: bigint): bigint {
27703 if(!isWasmInitialized) {
27704 throw new Error("initializeWasm() must be awaited first!");
27706 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
27707 return nativeResponseValue;
27709 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
27711 export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
27712 if(!isWasmInitialized) {
27713 throw new Error("initializeWasm() must be awaited first!");
27715 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
27716 // debug statements here
27718 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
27720 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
27721 if(!isWasmInitialized) {
27722 throw new Error("initializeWasm() must be awaited first!");
27724 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
27725 return nativeResponseValue;
27727 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
27729 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
27730 if(!isWasmInitialized) {
27731 throw new Error("initializeWasm() must be awaited first!");
27733 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
27734 // debug statements here
27736 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
27738 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
27739 if(!isWasmInitialized) {
27740 throw new Error("initializeWasm() must be awaited first!");
27742 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
27743 return nativeResponseValue;
27745 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
27747 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
27748 if(!isWasmInitialized) {
27749 throw new Error("initializeWasm() must be awaited first!");
27751 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
27752 // debug statements here
27754 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
27756 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
27757 if(!isWasmInitialized) {
27758 throw new Error("initializeWasm() must be awaited first!");
27760 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
27761 return nativeResponseValue;
27763 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
27765 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
27766 if(!isWasmInitialized) {
27767 throw new Error("initializeWasm() must be awaited first!");
27769 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
27770 // debug statements here
27772 // 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);
27774 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
27775 if(!isWasmInitialized) {
27776 throw new Error("initializeWasm() must be awaited first!");
27778 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
27779 return nativeResponseValue;
27781 // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
27783 export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
27784 if(!isWasmInitialized) {
27785 throw new Error("initializeWasm() must be awaited first!");
27787 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
27788 return nativeResponseValue;
27790 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
27792 export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
27793 if(!isWasmInitialized) {
27794 throw new Error("initializeWasm() must be awaited first!");
27796 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
27797 return nativeResponseValue;
27799 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
27801 export function ChannelCounterparty_free(this_obj: bigint): void {
27802 if(!isWasmInitialized) {
27803 throw new Error("initializeWasm() must be awaited first!");
27805 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
27806 // debug statements here
27808 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27810 export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
27811 if(!isWasmInitialized) {
27812 throw new Error("initializeWasm() must be awaited first!");
27814 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
27815 return nativeResponseValue;
27817 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27819 export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
27820 if(!isWasmInitialized) {
27821 throw new Error("initializeWasm() must be awaited first!");
27823 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
27824 // debug statements here
27826 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27828 export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
27829 if(!isWasmInitialized) {
27830 throw new Error("initializeWasm() must be awaited first!");
27832 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
27833 return nativeResponseValue;
27835 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
27837 export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
27838 if(!isWasmInitialized) {
27839 throw new Error("initializeWasm() must be awaited first!");
27841 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
27842 // debug statements here
27844 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27846 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
27847 if(!isWasmInitialized) {
27848 throw new Error("initializeWasm() must be awaited first!");
27850 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
27851 return nativeResponseValue;
27853 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
27855 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
27856 if(!isWasmInitialized) {
27857 throw new Error("initializeWasm() must be awaited first!");
27859 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
27860 // debug statements here
27862 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27864 export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
27865 if(!isWasmInitialized) {
27866 throw new Error("initializeWasm() must be awaited first!");
27868 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
27869 return nativeResponseValue;
27871 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
27873 export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
27874 if(!isWasmInitialized) {
27875 throw new Error("initializeWasm() must be awaited first!");
27877 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
27878 // debug statements here
27880 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27882 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
27883 if(!isWasmInitialized) {
27884 throw new Error("initializeWasm() must be awaited first!");
27886 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
27887 return nativeResponseValue;
27889 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27891 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
27892 if(!isWasmInitialized) {
27893 throw new Error("initializeWasm() must be awaited first!");
27895 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
27896 // debug statements here
27898 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
27900 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
27901 if(!isWasmInitialized) {
27902 throw new Error("initializeWasm() must be awaited first!");
27904 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
27905 return nativeResponseValue;
27907 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27909 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
27910 if(!isWasmInitialized) {
27911 throw new Error("initializeWasm() must be awaited first!");
27913 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
27914 // debug statements here
27916 // 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);
27918 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 {
27919 if(!isWasmInitialized) {
27920 throw new Error("initializeWasm() must be awaited first!");
27922 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);
27923 return nativeResponseValue;
27925 // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
27927 export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
27928 if(!isWasmInitialized) {
27929 throw new Error("initializeWasm() must be awaited first!");
27931 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
27932 return nativeResponseValue;
27934 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
27936 export function ChannelCounterparty_clone(orig: bigint): bigint {
27937 if(!isWasmInitialized) {
27938 throw new Error("initializeWasm() must be awaited first!");
27940 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
27941 return nativeResponseValue;
27943 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
27945 export function ChannelDetails_free(this_obj: bigint): void {
27946 if(!isWasmInitialized) {
27947 throw new Error("initializeWasm() must be awaited first!");
27949 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
27950 // debug statements here
27952 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
27954 export function ChannelDetails_get_channel_id(this_ptr: bigint): number {
27955 if(!isWasmInitialized) {
27956 throw new Error("initializeWasm() must be awaited first!");
27958 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
27959 return nativeResponseValue;
27961 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27963 export function ChannelDetails_set_channel_id(this_ptr: bigint, val: number): void {
27964 if(!isWasmInitialized) {
27965 throw new Error("initializeWasm() must be awaited first!");
27967 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
27968 // debug statements here
27970 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27972 export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
27973 if(!isWasmInitialized) {
27974 throw new Error("initializeWasm() must be awaited first!");
27976 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
27977 return nativeResponseValue;
27979 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
27981 export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
27982 if(!isWasmInitialized) {
27983 throw new Error("initializeWasm() must be awaited first!");
27985 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
27986 // debug statements here
27988 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
27990 export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
27991 if(!isWasmInitialized) {
27992 throw new Error("initializeWasm() must be awaited first!");
27994 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
27995 return nativeResponseValue;
27997 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
27999 export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
28000 if(!isWasmInitialized) {
28001 throw new Error("initializeWasm() must be awaited first!");
28003 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
28004 // debug statements here
28006 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28008 export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
28009 if(!isWasmInitialized) {
28010 throw new Error("initializeWasm() must be awaited first!");
28012 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
28013 return nativeResponseValue;
28015 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
28017 export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
28018 if(!isWasmInitialized) {
28019 throw new Error("initializeWasm() must be awaited first!");
28021 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
28022 // debug statements here
28024 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28026 export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
28027 if(!isWasmInitialized) {
28028 throw new Error("initializeWasm() must be awaited first!");
28030 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
28031 return nativeResponseValue;
28033 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28035 export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
28036 if(!isWasmInitialized) {
28037 throw new Error("initializeWasm() must be awaited first!");
28039 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
28040 // debug statements here
28042 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28044 export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
28045 if(!isWasmInitialized) {
28046 throw new Error("initializeWasm() must be awaited first!");
28048 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
28049 return nativeResponseValue;
28051 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28053 export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
28054 if(!isWasmInitialized) {
28055 throw new Error("initializeWasm() must be awaited first!");
28057 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
28058 // debug statements here
28060 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28062 export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
28063 if(!isWasmInitialized) {
28064 throw new Error("initializeWasm() must be awaited first!");
28066 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
28067 return nativeResponseValue;
28069 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28071 export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
28072 if(!isWasmInitialized) {
28073 throw new Error("initializeWasm() must be awaited first!");
28075 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
28076 // debug statements here
28078 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28080 export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
28081 if(!isWasmInitialized) {
28082 throw new Error("initializeWasm() must be awaited first!");
28084 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
28085 return nativeResponseValue;
28087 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
28089 export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
28090 if(!isWasmInitialized) {
28091 throw new Error("initializeWasm() must be awaited first!");
28093 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
28094 // debug statements here
28096 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28098 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
28099 if(!isWasmInitialized) {
28100 throw new Error("initializeWasm() must be awaited first!");
28102 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
28103 return nativeResponseValue;
28105 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28107 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
28108 if(!isWasmInitialized) {
28109 throw new Error("initializeWasm() must be awaited first!");
28111 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
28112 // debug statements here
28114 // struct LDKU128 ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28116 export function ChannelDetails_get_user_channel_id(this_ptr: bigint): number {
28117 if(!isWasmInitialized) {
28118 throw new Error("initializeWasm() must be awaited first!");
28120 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
28121 return nativeResponseValue;
28123 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKU128 val);
28125 export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: number): void {
28126 if(!isWasmInitialized) {
28127 throw new Error("initializeWasm() must be awaited first!");
28129 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
28130 // debug statements here
28132 // struct LDKCOption_u32Z ChannelDetails_get_feerate_sat_per_1000_weight(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28134 export function ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr: bigint): bigint {
28135 if(!isWasmInitialized) {
28136 throw new Error("initializeWasm() must be awaited first!");
28138 const nativeResponseValue = wasm.TS_ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr);
28139 return nativeResponseValue;
28141 // void ChannelDetails_set_feerate_sat_per_1000_weight(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
28143 export function ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: bigint): void {
28144 if(!isWasmInitialized) {
28145 throw new Error("initializeWasm() must be awaited first!");
28147 const nativeResponseValue = wasm.TS_ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr, val);
28148 // debug statements here
28150 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28152 export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
28153 if(!isWasmInitialized) {
28154 throw new Error("initializeWasm() must be awaited first!");
28156 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
28157 return nativeResponseValue;
28159 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
28161 export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
28162 if(!isWasmInitialized) {
28163 throw new Error("initializeWasm() must be awaited first!");
28165 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
28166 // debug statements here
28168 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28170 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
28171 if(!isWasmInitialized) {
28172 throw new Error("initializeWasm() must be awaited first!");
28174 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
28175 return nativeResponseValue;
28177 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
28179 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
28180 if(!isWasmInitialized) {
28181 throw new Error("initializeWasm() must be awaited first!");
28183 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
28184 // debug statements here
28186 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28188 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
28189 if(!isWasmInitialized) {
28190 throw new Error("initializeWasm() must be awaited first!");
28192 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
28193 return nativeResponseValue;
28195 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
28197 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
28198 if(!isWasmInitialized) {
28199 throw new Error("initializeWasm() must be awaited first!");
28201 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
28202 // debug statements here
28204 // uint64_t ChannelDetails_get_next_outbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28206 export function ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
28207 if(!isWasmInitialized) {
28208 throw new Error("initializeWasm() must be awaited first!");
28210 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr);
28211 return nativeResponseValue;
28213 // void ChannelDetails_set_next_outbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
28215 export function ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
28216 if(!isWasmInitialized) {
28217 throw new Error("initializeWasm() must be awaited first!");
28219 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr, val);
28220 // debug statements here
28222 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28224 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
28225 if(!isWasmInitialized) {
28226 throw new Error("initializeWasm() must be awaited first!");
28228 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
28229 return nativeResponseValue;
28231 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
28233 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
28234 if(!isWasmInitialized) {
28235 throw new Error("initializeWasm() must be awaited first!");
28237 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
28238 // debug statements here
28240 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28242 export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
28243 if(!isWasmInitialized) {
28244 throw new Error("initializeWasm() must be awaited first!");
28246 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
28247 return nativeResponseValue;
28249 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
28251 export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
28252 if(!isWasmInitialized) {
28253 throw new Error("initializeWasm() must be awaited first!");
28255 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
28256 // debug statements here
28258 // struct LDKCOption_u32Z ChannelDetails_get_confirmations(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28260 export function ChannelDetails_get_confirmations(this_ptr: bigint): bigint {
28261 if(!isWasmInitialized) {
28262 throw new Error("initializeWasm() must be awaited first!");
28264 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations(this_ptr);
28265 return nativeResponseValue;
28267 // void ChannelDetails_set_confirmations(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
28269 export function ChannelDetails_set_confirmations(this_ptr: bigint, val: bigint): void {
28270 if(!isWasmInitialized) {
28271 throw new Error("initializeWasm() must be awaited first!");
28273 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations(this_ptr, val);
28274 // debug statements here
28276 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28278 export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
28279 if(!isWasmInitialized) {
28280 throw new Error("initializeWasm() must be awaited first!");
28282 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
28283 return nativeResponseValue;
28285 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
28287 export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
28288 if(!isWasmInitialized) {
28289 throw new Error("initializeWasm() must be awaited first!");
28291 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
28292 // debug statements here
28294 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28296 export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
28297 if(!isWasmInitialized) {
28298 throw new Error("initializeWasm() must be awaited first!");
28300 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
28301 return nativeResponseValue;
28303 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
28305 export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
28306 if(!isWasmInitialized) {
28307 throw new Error("initializeWasm() must be awaited first!");
28309 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
28310 // debug statements here
28312 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28314 export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
28315 if(!isWasmInitialized) {
28316 throw new Error("initializeWasm() must be awaited first!");
28318 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
28319 return nativeResponseValue;
28321 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
28323 export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
28324 if(!isWasmInitialized) {
28325 throw new Error("initializeWasm() must be awaited first!");
28327 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
28328 // debug statements here
28330 // struct LDKCOption_ChannelShutdownStateZ ChannelDetails_get_channel_shutdown_state(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28332 export function ChannelDetails_get_channel_shutdown_state(this_ptr: bigint): bigint {
28333 if(!isWasmInitialized) {
28334 throw new Error("initializeWasm() must be awaited first!");
28336 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_shutdown_state(this_ptr);
28337 return nativeResponseValue;
28339 // void ChannelDetails_set_channel_shutdown_state(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_ChannelShutdownStateZ val);
28341 export function ChannelDetails_set_channel_shutdown_state(this_ptr: bigint, val: bigint): void {
28342 if(!isWasmInitialized) {
28343 throw new Error("initializeWasm() must be awaited first!");
28345 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_shutdown_state(this_ptr, val);
28346 // debug statements here
28348 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28350 export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
28351 if(!isWasmInitialized) {
28352 throw new Error("initializeWasm() must be awaited first!");
28354 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
28355 return nativeResponseValue;
28357 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
28359 export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
28360 if(!isWasmInitialized) {
28361 throw new Error("initializeWasm() must be awaited first!");
28363 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
28364 // debug statements here
28366 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28368 export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
28369 if(!isWasmInitialized) {
28370 throw new Error("initializeWasm() must be awaited first!");
28372 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
28373 return nativeResponseValue;
28375 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
28377 export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
28378 if(!isWasmInitialized) {
28379 throw new Error("initializeWasm() must be awaited first!");
28381 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
28382 // debug statements here
28384 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28386 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
28387 if(!isWasmInitialized) {
28388 throw new Error("initializeWasm() must be awaited first!");
28390 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
28391 return nativeResponseValue;
28393 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28395 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
28396 if(!isWasmInitialized) {
28397 throw new Error("initializeWasm() must be awaited first!");
28399 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
28400 // debug statements here
28402 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28404 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
28405 if(!isWasmInitialized) {
28406 throw new Error("initializeWasm() must be awaited first!");
28408 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
28409 return nativeResponseValue;
28411 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28413 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
28414 if(!isWasmInitialized) {
28415 throw new Error("initializeWasm() must be awaited first!");
28417 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
28418 // debug statements here
28420 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
28422 export function ChannelDetails_get_config(this_ptr: bigint): bigint {
28423 if(!isWasmInitialized) {
28424 throw new Error("initializeWasm() must be awaited first!");
28426 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
28427 return nativeResponseValue;
28429 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
28431 export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
28432 if(!isWasmInitialized) {
28433 throw new Error("initializeWasm() must be awaited first!");
28435 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
28436 // debug statements here
28438 // MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKChannelTypeFeatures channel_type_arg, struct LDKCOption_u64Z short_channel_id_arg, struct LDKCOption_u64Z outbound_scid_alias_arg, struct LDKCOption_u64Z inbound_scid_alias_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, struct LDKU128 user_channel_id_arg, struct LDKCOption_u32Z feerate_sat_per_1000_weight_arg, uint64_t balance_msat_arg, uint64_t outbound_capacity_msat_arg, uint64_t next_outbound_htlc_limit_msat_arg, uint64_t next_outbound_htlc_minimum_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u32Z confirmations_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_channel_ready_arg, struct LDKCOption_ChannelShutdownStateZ channel_shutdown_state_arg, bool is_usable_arg, bool is_public_arg, struct LDKCOption_u64Z inbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z inbound_htlc_maximum_msat_arg, struct LDKChannelConfig config_arg);
28440 export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: bigint, funding_txo_arg: bigint, channel_type_arg: bigint, short_channel_id_arg: bigint, outbound_scid_alias_arg: bigint, inbound_scid_alias_arg: bigint, channel_value_satoshis_arg: bigint, unspendable_punishment_reserve_arg: bigint, user_channel_id_arg: number, feerate_sat_per_1000_weight_arg: bigint, balance_msat_arg: bigint, outbound_capacity_msat_arg: bigint, next_outbound_htlc_limit_msat_arg: bigint, next_outbound_htlc_minimum_msat_arg: bigint, inbound_capacity_msat_arg: bigint, confirmations_required_arg: bigint, confirmations_arg: bigint, force_close_spend_delay_arg: bigint, is_outbound_arg: boolean, is_channel_ready_arg: boolean, channel_shutdown_state_arg: bigint, is_usable_arg: boolean, is_public_arg: boolean, inbound_htlc_minimum_msat_arg: bigint, inbound_htlc_maximum_msat_arg: bigint, config_arg: bigint): bigint {
28441 if(!isWasmInitialized) {
28442 throw new Error("initializeWasm() must be awaited first!");
28444 const nativeResponseValue = wasm.TS_ChannelDetails_new(channel_id_arg, counterparty_arg, funding_txo_arg, channel_type_arg, short_channel_id_arg, outbound_scid_alias_arg, inbound_scid_alias_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, feerate_sat_per_1000_weight_arg, balance_msat_arg, outbound_capacity_msat_arg, next_outbound_htlc_limit_msat_arg, next_outbound_htlc_minimum_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, confirmations_arg, force_close_spend_delay_arg, is_outbound_arg, is_channel_ready_arg, channel_shutdown_state_arg, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg, inbound_htlc_maximum_msat_arg, config_arg);
28445 return nativeResponseValue;
28447 // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
28449 export function ChannelDetails_clone_ptr(arg: bigint): bigint {
28450 if(!isWasmInitialized) {
28451 throw new Error("initializeWasm() must be awaited first!");
28453 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
28454 return nativeResponseValue;
28456 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
28458 export function ChannelDetails_clone(orig: bigint): bigint {
28459 if(!isWasmInitialized) {
28460 throw new Error("initializeWasm() must be awaited first!");
28462 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
28463 return nativeResponseValue;
28465 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
28467 export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
28468 if(!isWasmInitialized) {
28469 throw new Error("initializeWasm() must be awaited first!");
28471 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
28472 return nativeResponseValue;
28474 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
28476 export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
28477 if(!isWasmInitialized) {
28478 throw new Error("initializeWasm() must be awaited first!");
28480 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
28481 return nativeResponseValue;
28483 // enum LDKChannelShutdownState ChannelShutdownState_clone(const enum LDKChannelShutdownState *NONNULL_PTR orig);
28485 export function ChannelShutdownState_clone(orig: bigint): ChannelShutdownState {
28486 if(!isWasmInitialized) {
28487 throw new Error("initializeWasm() must be awaited first!");
28489 const nativeResponseValue = wasm.TS_ChannelShutdownState_clone(orig);
28490 return nativeResponseValue;
28492 // enum LDKChannelShutdownState ChannelShutdownState_not_shutting_down(void);
28494 export function ChannelShutdownState_not_shutting_down(): ChannelShutdownState {
28495 if(!isWasmInitialized) {
28496 throw new Error("initializeWasm() must be awaited first!");
28498 const nativeResponseValue = wasm.TS_ChannelShutdownState_not_shutting_down();
28499 return nativeResponseValue;
28501 // enum LDKChannelShutdownState ChannelShutdownState_shutdown_initiated(void);
28503 export function ChannelShutdownState_shutdown_initiated(): ChannelShutdownState {
28504 if(!isWasmInitialized) {
28505 throw new Error("initializeWasm() must be awaited first!");
28507 const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_initiated();
28508 return nativeResponseValue;
28510 // enum LDKChannelShutdownState ChannelShutdownState_resolving_htlcs(void);
28512 export function ChannelShutdownState_resolving_htlcs(): ChannelShutdownState {
28513 if(!isWasmInitialized) {
28514 throw new Error("initializeWasm() must be awaited first!");
28516 const nativeResponseValue = wasm.TS_ChannelShutdownState_resolving_htlcs();
28517 return nativeResponseValue;
28519 // enum LDKChannelShutdownState ChannelShutdownState_negotiating_closing_fee(void);
28521 export function ChannelShutdownState_negotiating_closing_fee(): ChannelShutdownState {
28522 if(!isWasmInitialized) {
28523 throw new Error("initializeWasm() must be awaited first!");
28525 const nativeResponseValue = wasm.TS_ChannelShutdownState_negotiating_closing_fee();
28526 return nativeResponseValue;
28528 // enum LDKChannelShutdownState ChannelShutdownState_shutdown_complete(void);
28530 export function ChannelShutdownState_shutdown_complete(): ChannelShutdownState {
28531 if(!isWasmInitialized) {
28532 throw new Error("initializeWasm() must be awaited first!");
28534 const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_complete();
28535 return nativeResponseValue;
28537 // bool ChannelShutdownState_eq(const enum LDKChannelShutdownState *NONNULL_PTR a, const enum LDKChannelShutdownState *NONNULL_PTR b);
28539 export function ChannelShutdownState_eq(a: bigint, b: bigint): boolean {
28540 if(!isWasmInitialized) {
28541 throw new Error("initializeWasm() must be awaited first!");
28543 const nativeResponseValue = wasm.TS_ChannelShutdownState_eq(a, b);
28544 return nativeResponseValue;
28546 // void RecentPaymentDetails_free(struct LDKRecentPaymentDetails this_ptr);
28548 export function RecentPaymentDetails_free(this_ptr: bigint): void {
28549 if(!isWasmInitialized) {
28550 throw new Error("initializeWasm() must be awaited first!");
28552 const nativeResponseValue = wasm.TS_RecentPaymentDetails_free(this_ptr);
28553 // debug statements here
28555 // uint64_t RecentPaymentDetails_clone_ptr(LDKRecentPaymentDetails *NONNULL_PTR arg);
28557 export function RecentPaymentDetails_clone_ptr(arg: bigint): bigint {
28558 if(!isWasmInitialized) {
28559 throw new Error("initializeWasm() must be awaited first!");
28561 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone_ptr(arg);
28562 return nativeResponseValue;
28564 // struct LDKRecentPaymentDetails RecentPaymentDetails_clone(const struct LDKRecentPaymentDetails *NONNULL_PTR orig);
28566 export function RecentPaymentDetails_clone(orig: bigint): bigint {
28567 if(!isWasmInitialized) {
28568 throw new Error("initializeWasm() must be awaited first!");
28570 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone(orig);
28571 return nativeResponseValue;
28573 // struct LDKRecentPaymentDetails RecentPaymentDetails_awaiting_invoice(struct LDKThirtyTwoBytes payment_id);
28575 export function RecentPaymentDetails_awaiting_invoice(payment_id: number): bigint {
28576 if(!isWasmInitialized) {
28577 throw new Error("initializeWasm() must be awaited first!");
28579 const nativeResponseValue = wasm.TS_RecentPaymentDetails_awaiting_invoice(payment_id);
28580 return nativeResponseValue;
28582 // struct LDKRecentPaymentDetails RecentPaymentDetails_pending(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, uint64_t total_msat);
28584 export function RecentPaymentDetails_pending(payment_id: number, payment_hash: number, total_msat: bigint): bigint {
28585 if(!isWasmInitialized) {
28586 throw new Error("initializeWasm() must be awaited first!");
28588 const nativeResponseValue = wasm.TS_RecentPaymentDetails_pending(payment_id, payment_hash, total_msat);
28589 return nativeResponseValue;
28591 // struct LDKRecentPaymentDetails RecentPaymentDetails_fulfilled(struct LDKThirtyTwoBytes payment_id, struct LDKCOption_ThirtyTwoBytesZ payment_hash);
28593 export function RecentPaymentDetails_fulfilled(payment_id: number, payment_hash: bigint): bigint {
28594 if(!isWasmInitialized) {
28595 throw new Error("initializeWasm() must be awaited first!");
28597 const nativeResponseValue = wasm.TS_RecentPaymentDetails_fulfilled(payment_id, payment_hash);
28598 return nativeResponseValue;
28600 // struct LDKRecentPaymentDetails RecentPaymentDetails_abandoned(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
28602 export function RecentPaymentDetails_abandoned(payment_id: number, payment_hash: number): bigint {
28603 if(!isWasmInitialized) {
28604 throw new Error("initializeWasm() must be awaited first!");
28606 const nativeResponseValue = wasm.TS_RecentPaymentDetails_abandoned(payment_id, payment_hash);
28607 return nativeResponseValue;
28609 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
28611 export function PhantomRouteHints_free(this_obj: bigint): void {
28612 if(!isWasmInitialized) {
28613 throw new Error("initializeWasm() must be awaited first!");
28615 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
28616 // debug statements here
28618 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
28620 export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
28621 if(!isWasmInitialized) {
28622 throw new Error("initializeWasm() must be awaited first!");
28624 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
28625 return nativeResponseValue;
28627 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
28629 export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
28630 if(!isWasmInitialized) {
28631 throw new Error("initializeWasm() must be awaited first!");
28633 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
28634 // debug statements here
28636 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
28638 export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
28639 if(!isWasmInitialized) {
28640 throw new Error("initializeWasm() must be awaited first!");
28642 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
28643 return nativeResponseValue;
28645 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
28647 export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
28648 if(!isWasmInitialized) {
28649 throw new Error("initializeWasm() must be awaited first!");
28651 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
28652 // debug statements here
28654 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
28656 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
28657 if(!isWasmInitialized) {
28658 throw new Error("initializeWasm() must be awaited first!");
28660 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
28661 return nativeResponseValue;
28663 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28665 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
28666 if(!isWasmInitialized) {
28667 throw new Error("initializeWasm() must be awaited first!");
28669 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
28670 // debug statements here
28672 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
28674 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
28675 if(!isWasmInitialized) {
28676 throw new Error("initializeWasm() must be awaited first!");
28678 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
28679 return nativeResponseValue;
28681 // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
28683 export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
28684 if(!isWasmInitialized) {
28685 throw new Error("initializeWasm() must be awaited first!");
28687 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
28688 return nativeResponseValue;
28690 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
28692 export function PhantomRouteHints_clone(orig: bigint): bigint {
28693 if(!isWasmInitialized) {
28694 throw new Error("initializeWasm() must be awaited first!");
28696 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
28697 return nativeResponseValue;
28699 // 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);
28701 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 {
28702 if(!isWasmInitialized) {
28703 throw new Error("initializeWasm() must be awaited first!");
28705 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, router, logger, entropy_source, node_signer, signer_provider, config, params, current_timestamp);
28706 return nativeResponseValue;
28708 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
28710 export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
28711 if(!isWasmInitialized) {
28712 throw new Error("initializeWasm() must be awaited first!");
28714 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
28715 return nativeResponseValue;
28717 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesAPIErrorZ ChannelManager_create_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, struct LDKU128 user_channel_id, struct LDKUserConfig override_config);
28719 export function ChannelManager_create_channel(this_arg: bigint, their_network_key: number, channel_value_satoshis: bigint, push_msat: bigint, user_channel_id: number, override_config: bigint): bigint {
28720 if(!isWasmInitialized) {
28721 throw new Error("initializeWasm() must be awaited first!");
28723 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
28724 return nativeResponseValue;
28726 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
28728 export function ChannelManager_list_channels(this_arg: bigint): number {
28729 if(!isWasmInitialized) {
28730 throw new Error("initializeWasm() must be awaited first!");
28732 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
28733 return nativeResponseValue;
28735 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
28737 export function ChannelManager_list_usable_channels(this_arg: bigint): number {
28738 if(!isWasmInitialized) {
28739 throw new Error("initializeWasm() must be awaited first!");
28741 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
28742 return nativeResponseValue;
28744 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels_with_counterparty(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id);
28746 export function ChannelManager_list_channels_with_counterparty(this_arg: bigint, counterparty_node_id: number): number {
28747 if(!isWasmInitialized) {
28748 throw new Error("initializeWasm() must be awaited first!");
28750 const nativeResponseValue = wasm.TS_ChannelManager_list_channels_with_counterparty(this_arg, counterparty_node_id);
28751 return nativeResponseValue;
28753 // MUST_USE_RES struct LDKCVec_RecentPaymentDetailsZ ChannelManager_list_recent_payments(const struct LDKChannelManager *NONNULL_PTR this_arg);
28755 export function ChannelManager_list_recent_payments(this_arg: bigint): number {
28756 if(!isWasmInitialized) {
28757 throw new Error("initializeWasm() must be awaited first!");
28759 const nativeResponseValue = wasm.TS_ChannelManager_list_recent_payments(this_arg);
28760 return nativeResponseValue;
28762 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
28764 export function ChannelManager_close_channel(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
28765 if(!isWasmInitialized) {
28766 throw new Error("initializeWasm() must be awaited first!");
28768 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
28769 return nativeResponseValue;
28771 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel_with_feerate_and_script(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id, struct LDKCOption_u32Z target_feerate_sats_per_1000_weight, struct LDKShutdownScript shutdown_script);
28773 export function ChannelManager_close_channel_with_feerate_and_script(this_arg: bigint, channel_id: number, counterparty_node_id: number, target_feerate_sats_per_1000_weight: bigint, shutdown_script: bigint): bigint {
28774 if(!isWasmInitialized) {
28775 throw new Error("initializeWasm() must be awaited first!");
28777 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);
28778 return nativeResponseValue;
28780 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
28782 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
28783 if(!isWasmInitialized) {
28784 throw new Error("initializeWasm() must be awaited first!");
28786 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
28787 return nativeResponseValue;
28789 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
28791 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
28792 if(!isWasmInitialized) {
28793 throw new Error("initializeWasm() must be awaited first!");
28795 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
28796 return nativeResponseValue;
28798 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
28800 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
28801 if(!isWasmInitialized) {
28802 throw new Error("initializeWasm() must be awaited first!");
28804 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
28805 // debug statements here
28807 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
28809 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
28810 if(!isWasmInitialized) {
28811 throw new Error("initializeWasm() must be awaited first!");
28813 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
28814 // debug statements here
28816 // 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);
28818 export function ChannelManager_send_payment_with_route(this_arg: bigint, route: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number): bigint {
28819 if(!isWasmInitialized) {
28820 throw new Error("initializeWasm() must be awaited first!");
28822 const nativeResponseValue = wasm.TS_ChannelManager_send_payment_with_route(this_arg, route, payment_hash, recipient_onion, payment_id);
28823 return nativeResponseValue;
28825 // 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);
28827 export function ChannelManager_send_payment(this_arg: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
28828 if(!isWasmInitialized) {
28829 throw new Error("initializeWasm() must be awaited first!");
28831 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, payment_hash, recipient_onion, payment_id, route_params, retry_strategy);
28832 return nativeResponseValue;
28834 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
28836 export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
28837 if(!isWasmInitialized) {
28838 throw new Error("initializeWasm() must be awaited first!");
28840 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
28841 // debug statements here
28843 // 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);
28845 export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: bigint, recipient_onion: bigint, payment_id: number): bigint {
28846 if(!isWasmInitialized) {
28847 throw new Error("initializeWasm() must be awaited first!");
28849 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage, recipient_onion, payment_id);
28850 return nativeResponseValue;
28852 // 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);
28854 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 {
28855 if(!isWasmInitialized) {
28856 throw new Error("initializeWasm() must be awaited first!");
28858 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment_with_retry(this_arg, payment_preimage, recipient_onion, payment_id, route_params, retry_strategy);
28859 return nativeResponseValue;
28861 // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPath path);
28863 export function ChannelManager_send_probe(this_arg: bigint, path: bigint): bigint {
28864 if(!isWasmInitialized) {
28865 throw new Error("initializeWasm() must be awaited first!");
28867 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, path);
28868 return nativeResponseValue;
28870 // 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);
28872 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 {
28873 if(!isWasmInitialized) {
28874 throw new Error("initializeWasm() must be awaited first!");
28876 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_preflight_probes(this_arg, node_id, amount_msat, final_cltv_expiry_delta, liquidity_limit_multiplier);
28877 return nativeResponseValue;
28879 // 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);
28881 export function ChannelManager_send_preflight_probes(this_arg: bigint, route_params: bigint, liquidity_limit_multiplier: bigint): bigint {
28882 if(!isWasmInitialized) {
28883 throw new Error("initializeWasm() must be awaited first!");
28885 const nativeResponseValue = wasm.TS_ChannelManager_send_preflight_probes(this_arg, route_params, liquidity_limit_multiplier);
28886 return nativeResponseValue;
28888 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKPublicKey counterparty_node_id, struct LDKTransaction funding_transaction);
28890 export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): bigint {
28891 if(!isWasmInitialized) {
28892 throw new Error("initializeWasm() must be awaited first!");
28894 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
28895 return nativeResponseValue;
28897 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_batch_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ temporary_channels, struct LDKTransaction funding_transaction);
28899 export function ChannelManager_batch_funding_transaction_generated(this_arg: bigint, temporary_channels: number, funding_transaction: number): bigint {
28900 if(!isWasmInitialized) {
28901 throw new Error("initializeWasm() must be awaited first!");
28903 const nativeResponseValue = wasm.TS_ChannelManager_batch_funding_transaction_generated(this_arg, temporary_channels, funding_transaction);
28904 return nativeResponseValue;
28906 // 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_ThirtyTwoBytesZ channel_ids, const struct LDKChannelConfigUpdate *NONNULL_PTR config_update);
28908 export function ChannelManager_update_partial_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config_update: bigint): bigint {
28909 if(!isWasmInitialized) {
28910 throw new Error("initializeWasm() must be awaited first!");
28912 const nativeResponseValue = wasm.TS_ChannelManager_update_partial_channel_config(this_arg, counterparty_node_id, channel_ids, config_update);
28913 return nativeResponseValue;
28915 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_update_channel_config(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id, struct LDKCVec_ThirtyTwoBytesZ channel_ids, const struct LDKChannelConfig *NONNULL_PTR config);
28917 export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
28918 if(!isWasmInitialized) {
28919 throw new Error("initializeWasm() must be awaited first!");
28921 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
28922 return nativeResponseValue;
28924 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_forward_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id, const uint8_t (*next_hop_channel_id)[32], struct LDKPublicKey next_node_id, uint64_t amt_to_forward_msat);
28926 export function ChannelManager_forward_intercepted_htlc(this_arg: bigint, intercept_id: number, next_hop_channel_id: number, next_node_id: number, amt_to_forward_msat: bigint): bigint {
28927 if(!isWasmInitialized) {
28928 throw new Error("initializeWasm() must be awaited first!");
28930 const nativeResponseValue = wasm.TS_ChannelManager_forward_intercepted_htlc(this_arg, intercept_id, next_hop_channel_id, next_node_id, amt_to_forward_msat);
28931 return nativeResponseValue;
28933 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_fail_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id);
28935 export function ChannelManager_fail_intercepted_htlc(this_arg: bigint, intercept_id: number): bigint {
28936 if(!isWasmInitialized) {
28937 throw new Error("initializeWasm() must be awaited first!");
28939 const nativeResponseValue = wasm.TS_ChannelManager_fail_intercepted_htlc(this_arg, intercept_id);
28940 return nativeResponseValue;
28942 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
28944 export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
28945 if(!isWasmInitialized) {
28946 throw new Error("initializeWasm() must be awaited first!");
28948 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
28949 // debug statements here
28951 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
28953 export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
28954 if(!isWasmInitialized) {
28955 throw new Error("initializeWasm() must be awaited first!");
28957 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
28958 // debug statements here
28960 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
28962 export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
28963 if(!isWasmInitialized) {
28964 throw new Error("initializeWasm() must be awaited first!");
28966 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
28967 // debug statements here
28969 // void ChannelManager_fail_htlc_backwards_with_reason(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32], struct LDKFailureCode failure_code);
28971 export function ChannelManager_fail_htlc_backwards_with_reason(this_arg: bigint, payment_hash: number, failure_code: bigint): void {
28972 if(!isWasmInitialized) {
28973 throw new Error("initializeWasm() must be awaited first!");
28975 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards_with_reason(this_arg, payment_hash, failure_code);
28976 // debug statements here
28978 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
28980 export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
28981 if(!isWasmInitialized) {
28982 throw new Error("initializeWasm() must be awaited first!");
28984 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
28985 // debug statements here
28987 // void ChannelManager_claim_funds_with_known_custom_tlvs(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
28989 export function ChannelManager_claim_funds_with_known_custom_tlvs(this_arg: bigint, payment_preimage: number): void {
28990 if(!isWasmInitialized) {
28991 throw new Error("initializeWasm() must be awaited first!");
28993 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds_with_known_custom_tlvs(this_arg, payment_preimage);
28994 // debug statements here
28996 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
28998 export function ChannelManager_get_our_node_id(this_arg: bigint): number {
28999 if(!isWasmInitialized) {
29000 throw new Error("initializeWasm() must be awaited first!");
29002 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
29003 return nativeResponseValue;
29005 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKPublicKey counterparty_node_id, struct LDKU128 user_channel_id);
29007 export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: number): bigint {
29008 if(!isWasmInitialized) {
29009 throw new Error("initializeWasm() must be awaited first!");
29011 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
29012 return nativeResponseValue;
29014 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKPublicKey counterparty_node_id, struct LDKU128 user_channel_id);
29016 export function ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: number): bigint {
29017 if(!isWasmInitialized) {
29018 throw new Error("initializeWasm() must be awaited first!");
29020 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
29021 return nativeResponseValue;
29023 // 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);
29025 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 {
29026 if(!isWasmInitialized) {
29027 throw new Error("initializeWasm() must be awaited first!");
29029 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);
29030 return nativeResponseValue;
29032 // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ ChannelManager_request_refund_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRefund *NONNULL_PTR refund);
29034 export function ChannelManager_request_refund_payment(this_arg: bigint, refund: bigint): bigint {
29035 if(!isWasmInitialized) {
29036 throw new Error("initializeWasm() must be awaited first!");
29038 const nativeResponseValue = wasm.TS_ChannelManager_request_refund_payment(this_arg, refund);
29039 return nativeResponseValue;
29041 // 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);
29043 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 {
29044 if(!isWasmInitialized) {
29045 throw new Error("initializeWasm() must be awaited first!");
29047 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
29048 return nativeResponseValue;
29050 // 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);
29052 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 {
29053 if(!isWasmInitialized) {
29054 throw new Error("initializeWasm() must be awaited first!");
29056 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);
29057 return nativeResponseValue;
29059 // 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);
29061 export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
29062 if(!isWasmInitialized) {
29063 throw new Error("initializeWasm() must be awaited first!");
29065 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
29066 return nativeResponseValue;
29068 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
29070 export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
29071 if(!isWasmInitialized) {
29072 throw new Error("initializeWasm() must be awaited first!");
29074 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
29075 return nativeResponseValue;
29077 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
29079 export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
29080 if(!isWasmInitialized) {
29081 throw new Error("initializeWasm() must be awaited first!");
29083 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
29084 return nativeResponseValue;
29086 // MUST_USE_RES uint64_t ChannelManager_get_intercept_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
29088 export function ChannelManager_get_intercept_scid(this_arg: bigint): bigint {
29089 if(!isWasmInitialized) {
29090 throw new Error("initializeWasm() must be awaited first!");
29092 const nativeResponseValue = wasm.TS_ChannelManager_get_intercept_scid(this_arg);
29093 return nativeResponseValue;
29095 // MUST_USE_RES struct LDKInFlightHtlcs ChannelManager_compute_inflight_htlcs(const struct LDKChannelManager *NONNULL_PTR this_arg);
29097 export function ChannelManager_compute_inflight_htlcs(this_arg: bigint): bigint {
29098 if(!isWasmInitialized) {
29099 throw new Error("initializeWasm() must be awaited first!");
29101 const nativeResponseValue = wasm.TS_ChannelManager_compute_inflight_htlcs(this_arg);
29102 return nativeResponseValue;
29104 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
29106 export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
29107 if(!isWasmInitialized) {
29108 throw new Error("initializeWasm() must be awaited first!");
29110 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
29111 return nativeResponseValue;
29113 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
29115 export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
29116 if(!isWasmInitialized) {
29117 throw new Error("initializeWasm() must be awaited first!");
29119 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
29120 return nativeResponseValue;
29122 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
29124 export function ChannelManager_as_Listen(this_arg: bigint): bigint {
29125 if(!isWasmInitialized) {
29126 throw new Error("initializeWasm() must be awaited first!");
29128 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
29129 return nativeResponseValue;
29131 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
29133 export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
29134 if(!isWasmInitialized) {
29135 throw new Error("initializeWasm() must be awaited first!");
29137 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
29138 return nativeResponseValue;
29140 // MUST_USE_RES struct LDKFuture ChannelManager_get_event_or_persistence_needed_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
29142 export function ChannelManager_get_event_or_persistence_needed_future(this_arg: bigint): bigint {
29143 if(!isWasmInitialized) {
29144 throw new Error("initializeWasm() must be awaited first!");
29146 const nativeResponseValue = wasm.TS_ChannelManager_get_event_or_persistence_needed_future(this_arg);
29147 return nativeResponseValue;
29149 // MUST_USE_RES bool ChannelManager_get_and_clear_needs_persistence(const struct LDKChannelManager *NONNULL_PTR this_arg);
29151 export function ChannelManager_get_and_clear_needs_persistence(this_arg: bigint): boolean {
29152 if(!isWasmInitialized) {
29153 throw new Error("initializeWasm() must be awaited first!");
29155 const nativeResponseValue = wasm.TS_ChannelManager_get_and_clear_needs_persistence(this_arg);
29156 return nativeResponseValue;
29158 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
29160 export function ChannelManager_current_best_block(this_arg: bigint): bigint {
29161 if(!isWasmInitialized) {
29162 throw new Error("initializeWasm() must be awaited first!");
29164 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
29165 return nativeResponseValue;
29167 // MUST_USE_RES struct LDKNodeFeatures ChannelManager_node_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
29169 export function ChannelManager_node_features(this_arg: bigint): bigint {
29170 if(!isWasmInitialized) {
29171 throw new Error("initializeWasm() must be awaited first!");
29173 const nativeResponseValue = wasm.TS_ChannelManager_node_features(this_arg);
29174 return nativeResponseValue;
29176 // MUST_USE_RES struct LDKChannelFeatures ChannelManager_channel_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
29178 export function ChannelManager_channel_features(this_arg: bigint): bigint {
29179 if(!isWasmInitialized) {
29180 throw new Error("initializeWasm() must be awaited first!");
29182 const nativeResponseValue = wasm.TS_ChannelManager_channel_features(this_arg);
29183 return nativeResponseValue;
29185 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelManager_channel_type_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
29187 export function ChannelManager_channel_type_features(this_arg: bigint): bigint {
29188 if(!isWasmInitialized) {
29189 throw new Error("initializeWasm() must be awaited first!");
29191 const nativeResponseValue = wasm.TS_ChannelManager_channel_type_features(this_arg);
29192 return nativeResponseValue;
29194 // MUST_USE_RES struct LDKInitFeatures ChannelManager_init_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
29196 export function ChannelManager_init_features(this_arg: bigint): bigint {
29197 if(!isWasmInitialized) {
29198 throw new Error("initializeWasm() must be awaited first!");
29200 const nativeResponseValue = wasm.TS_ChannelManager_init_features(this_arg);
29201 return nativeResponseValue;
29203 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
29205 export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
29206 if(!isWasmInitialized) {
29207 throw new Error("initializeWasm() must be awaited first!");
29209 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
29210 return nativeResponseValue;
29212 // struct LDKOffersMessageHandler ChannelManager_as_OffersMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
29214 export function ChannelManager_as_OffersMessageHandler(this_arg: bigint): bigint {
29215 if(!isWasmInitialized) {
29216 throw new Error("initializeWasm() must be awaited first!");
29218 const nativeResponseValue = wasm.TS_ChannelManager_as_OffersMessageHandler(this_arg);
29219 return nativeResponseValue;
29221 // struct LDKInitFeatures provided_init_features(const struct LDKUserConfig *NONNULL_PTR config);
29223 export function provided_init_features(config: bigint): bigint {
29224 if(!isWasmInitialized) {
29225 throw new Error("initializeWasm() must be awaited first!");
29227 const nativeResponseValue = wasm.TS_provided_init_features(config);
29228 return nativeResponseValue;
29230 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
29232 export function CounterpartyForwardingInfo_write(obj: bigint): number {
29233 if(!isWasmInitialized) {
29234 throw new Error("initializeWasm() must be awaited first!");
29236 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
29237 return nativeResponseValue;
29239 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
29241 export function CounterpartyForwardingInfo_read(ser: number): bigint {
29242 if(!isWasmInitialized) {
29243 throw new Error("initializeWasm() must be awaited first!");
29245 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
29246 return nativeResponseValue;
29248 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
29250 export function ChannelCounterparty_write(obj: bigint): number {
29251 if(!isWasmInitialized) {
29252 throw new Error("initializeWasm() must be awaited first!");
29254 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
29255 return nativeResponseValue;
29257 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
29259 export function ChannelCounterparty_read(ser: number): bigint {
29260 if(!isWasmInitialized) {
29261 throw new Error("initializeWasm() must be awaited first!");
29263 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
29264 return nativeResponseValue;
29266 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
29268 export function ChannelDetails_write(obj: bigint): number {
29269 if(!isWasmInitialized) {
29270 throw new Error("initializeWasm() must be awaited first!");
29272 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
29273 return nativeResponseValue;
29275 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
29277 export function ChannelDetails_read(ser: number): bigint {
29278 if(!isWasmInitialized) {
29279 throw new Error("initializeWasm() must be awaited first!");
29281 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
29282 return nativeResponseValue;
29284 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
29286 export function PhantomRouteHints_write(obj: bigint): number {
29287 if(!isWasmInitialized) {
29288 throw new Error("initializeWasm() must be awaited first!");
29290 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
29291 return nativeResponseValue;
29293 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
29295 export function PhantomRouteHints_read(ser: number): bigint {
29296 if(!isWasmInitialized) {
29297 throw new Error("initializeWasm() must be awaited first!");
29299 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
29300 return nativeResponseValue;
29302 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
29304 export function ChannelManager_write(obj: bigint): number {
29305 if(!isWasmInitialized) {
29306 throw new Error("initializeWasm() must be awaited first!");
29308 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
29309 return nativeResponseValue;
29311 // struct LDKCVec_u8Z ChannelShutdownState_write(const enum LDKChannelShutdownState *NONNULL_PTR obj);
29313 export function ChannelShutdownState_write(obj: bigint): number {
29314 if(!isWasmInitialized) {
29315 throw new Error("initializeWasm() must be awaited first!");
29317 const nativeResponseValue = wasm.TS_ChannelShutdownState_write(obj);
29318 return nativeResponseValue;
29320 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ ChannelShutdownState_read(struct LDKu8slice ser);
29322 export function ChannelShutdownState_read(ser: number): bigint {
29323 if(!isWasmInitialized) {
29324 throw new Error("initializeWasm() must be awaited first!");
29326 const nativeResponseValue = wasm.TS_ChannelShutdownState_read(ser);
29327 return nativeResponseValue;
29329 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
29331 export function ChannelManagerReadArgs_free(this_obj: bigint): void {
29332 if(!isWasmInitialized) {
29333 throw new Error("initializeWasm() must be awaited first!");
29335 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
29336 // debug statements here
29338 // const struct LDKEntropySource *ChannelManagerReadArgs_get_entropy_source(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
29340 export function ChannelManagerReadArgs_get_entropy_source(this_ptr: bigint): bigint {
29341 if(!isWasmInitialized) {
29342 throw new Error("initializeWasm() must be awaited first!");
29344 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_entropy_source(this_ptr);
29345 return nativeResponseValue;
29347 // void ChannelManagerReadArgs_set_entropy_source(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKEntropySource val);
29349 export function ChannelManagerReadArgs_set_entropy_source(this_ptr: bigint, val: bigint): void {
29350 if(!isWasmInitialized) {
29351 throw new Error("initializeWasm() must be awaited first!");
29353 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_entropy_source(this_ptr, val);
29354 // debug statements here
29356 // const struct LDKNodeSigner *ChannelManagerReadArgs_get_node_signer(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
29358 export function ChannelManagerReadArgs_get_node_signer(this_ptr: bigint): bigint {
29359 if(!isWasmInitialized) {
29360 throw new Error("initializeWasm() must be awaited first!");
29362 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_node_signer(this_ptr);
29363 return nativeResponseValue;
29365 // void ChannelManagerReadArgs_set_node_signer(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKNodeSigner val);
29367 export function ChannelManagerReadArgs_set_node_signer(this_ptr: bigint, val: bigint): void {
29368 if(!isWasmInitialized) {
29369 throw new Error("initializeWasm() must be awaited first!");
29371 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_node_signer(this_ptr, val);
29372 // debug statements here
29374 // const struct LDKSignerProvider *ChannelManagerReadArgs_get_signer_provider(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
29376 export function ChannelManagerReadArgs_get_signer_provider(this_ptr: bigint): bigint {
29377 if(!isWasmInitialized) {
29378 throw new Error("initializeWasm() must be awaited first!");
29380 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_signer_provider(this_ptr);
29381 return nativeResponseValue;
29383 // void ChannelManagerReadArgs_set_signer_provider(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKSignerProvider val);
29385 export function ChannelManagerReadArgs_set_signer_provider(this_ptr: bigint, val: bigint): void {
29386 if(!isWasmInitialized) {
29387 throw new Error("initializeWasm() must be awaited first!");
29389 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_signer_provider(this_ptr, val);
29390 // debug statements here
29392 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
29394 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
29395 if(!isWasmInitialized) {
29396 throw new Error("initializeWasm() must be awaited first!");
29398 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
29399 return nativeResponseValue;
29401 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
29403 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
29404 if(!isWasmInitialized) {
29405 throw new Error("initializeWasm() must be awaited first!");
29407 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
29408 // debug statements here
29410 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
29412 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
29413 if(!isWasmInitialized) {
29414 throw new Error("initializeWasm() must be awaited first!");
29416 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
29417 return nativeResponseValue;
29419 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
29421 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
29422 if(!isWasmInitialized) {
29423 throw new Error("initializeWasm() must be awaited first!");
29425 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
29426 // debug statements here
29428 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
29430 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
29431 if(!isWasmInitialized) {
29432 throw new Error("initializeWasm() must be awaited first!");
29434 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
29435 return nativeResponseValue;
29437 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
29439 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
29440 if(!isWasmInitialized) {
29441 throw new Error("initializeWasm() must be awaited first!");
29443 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
29444 // debug statements here
29446 // const struct LDKRouter *ChannelManagerReadArgs_get_router(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
29448 export function ChannelManagerReadArgs_get_router(this_ptr: bigint): bigint {
29449 if(!isWasmInitialized) {
29450 throw new Error("initializeWasm() must be awaited first!");
29452 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_router(this_ptr);
29453 return nativeResponseValue;
29455 // void ChannelManagerReadArgs_set_router(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKRouter val);
29457 export function ChannelManagerReadArgs_set_router(this_ptr: bigint, val: bigint): void {
29458 if(!isWasmInitialized) {
29459 throw new Error("initializeWasm() must be awaited first!");
29461 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_router(this_ptr, val);
29462 // debug statements here
29464 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
29466 export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
29467 if(!isWasmInitialized) {
29468 throw new Error("initializeWasm() must be awaited first!");
29470 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
29471 return nativeResponseValue;
29473 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
29475 export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
29476 if(!isWasmInitialized) {
29477 throw new Error("initializeWasm() must be awaited first!");
29479 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
29480 // debug statements here
29482 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
29484 export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
29485 if(!isWasmInitialized) {
29486 throw new Error("initializeWasm() must be awaited first!");
29488 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
29489 return nativeResponseValue;
29491 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
29493 export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
29494 if(!isWasmInitialized) {
29495 throw new Error("initializeWasm() must be awaited first!");
29497 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
29498 // debug statements here
29500 // 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);
29502 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 {
29503 if(!isWasmInitialized) {
29504 throw new Error("initializeWasm() must be awaited first!");
29506 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(entropy_source, node_signer, signer_provider, fee_estimator, chain_monitor, tx_broadcaster, router, logger, default_config, channel_monitors);
29507 return nativeResponseValue;
29509 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ C2Tuple_ThirtyTwoBytesChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
29511 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser: number, arg: bigint): bigint {
29512 if(!isWasmInitialized) {
29513 throw new Error("initializeWasm() must be awaited first!");
29515 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser, arg);
29516 return nativeResponseValue;
29518 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
29520 export function ExpandedKey_free(this_obj: bigint): void {
29521 if(!isWasmInitialized) {
29522 throw new Error("initializeWasm() must be awaited first!");
29524 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
29525 // debug statements here
29527 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
29529 export function ExpandedKey_new(key_material: number): bigint {
29530 if(!isWasmInitialized) {
29531 throw new Error("initializeWasm() must be awaited first!");
29533 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
29534 return nativeResponseValue;
29536 // 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);
29538 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 {
29539 if(!isWasmInitialized) {
29540 throw new Error("initializeWasm() must be awaited first!");
29542 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, entropy_source, current_time, min_final_cltv_expiry_delta);
29543 return nativeResponseValue;
29545 // 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);
29547 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 {
29548 if(!isWasmInitialized) {
29549 throw new Error("initializeWasm() must be awaited first!");
29551 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time, min_final_cltv_expiry_delta);
29552 return nativeResponseValue;
29554 // void DecodeError_free(struct LDKDecodeError this_ptr);
29556 export function DecodeError_free(this_ptr: bigint): void {
29557 if(!isWasmInitialized) {
29558 throw new Error("initializeWasm() must be awaited first!");
29560 const nativeResponseValue = wasm.TS_DecodeError_free(this_ptr);
29561 // debug statements here
29563 // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
29565 export function DecodeError_clone_ptr(arg: bigint): bigint {
29566 if(!isWasmInitialized) {
29567 throw new Error("initializeWasm() must be awaited first!");
29569 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
29570 return nativeResponseValue;
29572 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
29574 export function DecodeError_clone(orig: bigint): bigint {
29575 if(!isWasmInitialized) {
29576 throw new Error("initializeWasm() must be awaited first!");
29578 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
29579 return nativeResponseValue;
29581 // struct LDKDecodeError DecodeError_unknown_version(void);
29583 export function DecodeError_unknown_version(): bigint {
29584 if(!isWasmInitialized) {
29585 throw new Error("initializeWasm() must be awaited first!");
29587 const nativeResponseValue = wasm.TS_DecodeError_unknown_version();
29588 return nativeResponseValue;
29590 // struct LDKDecodeError DecodeError_unknown_required_feature(void);
29592 export function DecodeError_unknown_required_feature(): bigint {
29593 if(!isWasmInitialized) {
29594 throw new Error("initializeWasm() must be awaited first!");
29596 const nativeResponseValue = wasm.TS_DecodeError_unknown_required_feature();
29597 return nativeResponseValue;
29599 // struct LDKDecodeError DecodeError_invalid_value(void);
29601 export function DecodeError_invalid_value(): bigint {
29602 if(!isWasmInitialized) {
29603 throw new Error("initializeWasm() must be awaited first!");
29605 const nativeResponseValue = wasm.TS_DecodeError_invalid_value();
29606 return nativeResponseValue;
29608 // struct LDKDecodeError DecodeError_short_read(void);
29610 export function DecodeError_short_read(): bigint {
29611 if(!isWasmInitialized) {
29612 throw new Error("initializeWasm() must be awaited first!");
29614 const nativeResponseValue = wasm.TS_DecodeError_short_read();
29615 return nativeResponseValue;
29617 // struct LDKDecodeError DecodeError_bad_length_descriptor(void);
29619 export function DecodeError_bad_length_descriptor(): bigint {
29620 if(!isWasmInitialized) {
29621 throw new Error("initializeWasm() must be awaited first!");
29623 const nativeResponseValue = wasm.TS_DecodeError_bad_length_descriptor();
29624 return nativeResponseValue;
29626 // struct LDKDecodeError DecodeError_io(enum LDKIOError a);
29628 export function DecodeError_io(a: IOError): bigint {
29629 if(!isWasmInitialized) {
29630 throw new Error("initializeWasm() must be awaited first!");
29632 const nativeResponseValue = wasm.TS_DecodeError_io(a);
29633 return nativeResponseValue;
29635 // struct LDKDecodeError DecodeError_unsupported_compression(void);
29637 export function DecodeError_unsupported_compression(): bigint {
29638 if(!isWasmInitialized) {
29639 throw new Error("initializeWasm() must be awaited first!");
29641 const nativeResponseValue = wasm.TS_DecodeError_unsupported_compression();
29642 return nativeResponseValue;
29644 // bool DecodeError_eq(const struct LDKDecodeError *NONNULL_PTR a, const struct LDKDecodeError *NONNULL_PTR b);
29646 export function DecodeError_eq(a: bigint, b: bigint): boolean {
29647 if(!isWasmInitialized) {
29648 throw new Error("initializeWasm() must be awaited first!");
29650 const nativeResponseValue = wasm.TS_DecodeError_eq(a, b);
29651 return nativeResponseValue;
29653 // void Init_free(struct LDKInit this_obj);
29655 export function Init_free(this_obj: bigint): void {
29656 if(!isWasmInitialized) {
29657 throw new Error("initializeWasm() must be awaited first!");
29659 const nativeResponseValue = wasm.TS_Init_free(this_obj);
29660 // debug statements here
29662 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
29664 export function Init_get_features(this_ptr: bigint): bigint {
29665 if(!isWasmInitialized) {
29666 throw new Error("initializeWasm() must be awaited first!");
29668 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
29669 return nativeResponseValue;
29671 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
29673 export function Init_set_features(this_ptr: bigint, val: bigint): void {
29674 if(!isWasmInitialized) {
29675 throw new Error("initializeWasm() must be awaited first!");
29677 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
29678 // debug statements here
29680 // struct LDKCOption_CVec_ThirtyTwoBytesZZ Init_get_networks(const struct LDKInit *NONNULL_PTR this_ptr);
29682 export function Init_get_networks(this_ptr: bigint): bigint {
29683 if(!isWasmInitialized) {
29684 throw new Error("initializeWasm() must be awaited first!");
29686 const nativeResponseValue = wasm.TS_Init_get_networks(this_ptr);
29687 return nativeResponseValue;
29689 // void Init_set_networks(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_CVec_ThirtyTwoBytesZZ val);
29691 export function Init_set_networks(this_ptr: bigint, val: bigint): void {
29692 if(!isWasmInitialized) {
29693 throw new Error("initializeWasm() must be awaited first!");
29695 const nativeResponseValue = wasm.TS_Init_set_networks(this_ptr, val);
29696 // debug statements here
29698 // struct LDKCOption_SocketAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
29700 export function Init_get_remote_network_address(this_ptr: bigint): bigint {
29701 if(!isWasmInitialized) {
29702 throw new Error("initializeWasm() must be awaited first!");
29704 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
29705 return nativeResponseValue;
29707 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_SocketAddressZ val);
29709 export function Init_set_remote_network_address(this_ptr: bigint, val: bigint): void {
29710 if(!isWasmInitialized) {
29711 throw new Error("initializeWasm() must be awaited first!");
29713 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
29714 // debug statements here
29716 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_CVec_ThirtyTwoBytesZZ networks_arg, struct LDKCOption_SocketAddressZ remote_network_address_arg);
29718 export function Init_new(features_arg: bigint, networks_arg: bigint, remote_network_address_arg: bigint): bigint {
29719 if(!isWasmInitialized) {
29720 throw new Error("initializeWasm() must be awaited first!");
29722 const nativeResponseValue = wasm.TS_Init_new(features_arg, networks_arg, remote_network_address_arg);
29723 return nativeResponseValue;
29725 // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
29727 export function Init_clone_ptr(arg: bigint): bigint {
29728 if(!isWasmInitialized) {
29729 throw new Error("initializeWasm() must be awaited first!");
29731 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
29732 return nativeResponseValue;
29734 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
29736 export function Init_clone(orig: bigint): bigint {
29737 if(!isWasmInitialized) {
29738 throw new Error("initializeWasm() must be awaited first!");
29740 const nativeResponseValue = wasm.TS_Init_clone(orig);
29741 return nativeResponseValue;
29743 // bool Init_eq(const struct LDKInit *NONNULL_PTR a, const struct LDKInit *NONNULL_PTR b);
29745 export function Init_eq(a: bigint, b: bigint): boolean {
29746 if(!isWasmInitialized) {
29747 throw new Error("initializeWasm() must be awaited first!");
29749 const nativeResponseValue = wasm.TS_Init_eq(a, b);
29750 return nativeResponseValue;
29752 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
29754 export function ErrorMessage_free(this_obj: bigint): void {
29755 if(!isWasmInitialized) {
29756 throw new Error("initializeWasm() must be awaited first!");
29758 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
29759 // debug statements here
29761 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
29763 export function ErrorMessage_get_channel_id(this_ptr: bigint): number {
29764 if(!isWasmInitialized) {
29765 throw new Error("initializeWasm() must be awaited first!");
29767 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
29768 return nativeResponseValue;
29770 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29772 export function ErrorMessage_set_channel_id(this_ptr: bigint, val: number): void {
29773 if(!isWasmInitialized) {
29774 throw new Error("initializeWasm() must be awaited first!");
29776 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
29777 // debug statements here
29779 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
29781 export function ErrorMessage_get_data(this_ptr: bigint): number {
29782 if(!isWasmInitialized) {
29783 throw new Error("initializeWasm() must be awaited first!");
29785 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
29786 return nativeResponseValue;
29788 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
29790 export function ErrorMessage_set_data(this_ptr: bigint, val: number): void {
29791 if(!isWasmInitialized) {
29792 throw new Error("initializeWasm() must be awaited first!");
29794 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
29795 // debug statements here
29797 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
29799 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): bigint {
29800 if(!isWasmInitialized) {
29801 throw new Error("initializeWasm() must be awaited first!");
29803 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
29804 return nativeResponseValue;
29806 // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
29808 export function ErrorMessage_clone_ptr(arg: bigint): bigint {
29809 if(!isWasmInitialized) {
29810 throw new Error("initializeWasm() must be awaited first!");
29812 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
29813 return nativeResponseValue;
29815 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
29817 export function ErrorMessage_clone(orig: bigint): bigint {
29818 if(!isWasmInitialized) {
29819 throw new Error("initializeWasm() must be awaited first!");
29821 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
29822 return nativeResponseValue;
29824 // bool ErrorMessage_eq(const struct LDKErrorMessage *NONNULL_PTR a, const struct LDKErrorMessage *NONNULL_PTR b);
29826 export function ErrorMessage_eq(a: bigint, b: bigint): boolean {
29827 if(!isWasmInitialized) {
29828 throw new Error("initializeWasm() must be awaited first!");
29830 const nativeResponseValue = wasm.TS_ErrorMessage_eq(a, b);
29831 return nativeResponseValue;
29833 // void WarningMessage_free(struct LDKWarningMessage this_obj);
29835 export function WarningMessage_free(this_obj: bigint): void {
29836 if(!isWasmInitialized) {
29837 throw new Error("initializeWasm() must be awaited first!");
29839 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
29840 // debug statements here
29842 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
29844 export function WarningMessage_get_channel_id(this_ptr: bigint): number {
29845 if(!isWasmInitialized) {
29846 throw new Error("initializeWasm() must be awaited first!");
29848 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
29849 return nativeResponseValue;
29851 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29853 export function WarningMessage_set_channel_id(this_ptr: bigint, val: number): void {
29854 if(!isWasmInitialized) {
29855 throw new Error("initializeWasm() must be awaited first!");
29857 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
29858 // debug statements here
29860 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
29862 export function WarningMessage_get_data(this_ptr: bigint): number {
29863 if(!isWasmInitialized) {
29864 throw new Error("initializeWasm() must be awaited first!");
29866 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
29867 return nativeResponseValue;
29869 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
29871 export function WarningMessage_set_data(this_ptr: bigint, val: number): void {
29872 if(!isWasmInitialized) {
29873 throw new Error("initializeWasm() must be awaited first!");
29875 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
29876 // debug statements here
29878 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
29880 export function WarningMessage_new(channel_id_arg: number, data_arg: number): bigint {
29881 if(!isWasmInitialized) {
29882 throw new Error("initializeWasm() must be awaited first!");
29884 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
29885 return nativeResponseValue;
29887 // uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
29889 export function WarningMessage_clone_ptr(arg: bigint): bigint {
29890 if(!isWasmInitialized) {
29891 throw new Error("initializeWasm() must be awaited first!");
29893 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
29894 return nativeResponseValue;
29896 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
29898 export function WarningMessage_clone(orig: bigint): bigint {
29899 if(!isWasmInitialized) {
29900 throw new Error("initializeWasm() must be awaited first!");
29902 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
29903 return nativeResponseValue;
29905 // bool WarningMessage_eq(const struct LDKWarningMessage *NONNULL_PTR a, const struct LDKWarningMessage *NONNULL_PTR b);
29907 export function WarningMessage_eq(a: bigint, b: bigint): boolean {
29908 if(!isWasmInitialized) {
29909 throw new Error("initializeWasm() must be awaited first!");
29911 const nativeResponseValue = wasm.TS_WarningMessage_eq(a, b);
29912 return nativeResponseValue;
29914 // void Ping_free(struct LDKPing this_obj);
29916 export function Ping_free(this_obj: bigint): void {
29917 if(!isWasmInitialized) {
29918 throw new Error("initializeWasm() must be awaited first!");
29920 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
29921 // debug statements here
29923 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
29925 export function Ping_get_ponglen(this_ptr: bigint): number {
29926 if(!isWasmInitialized) {
29927 throw new Error("initializeWasm() must be awaited first!");
29929 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
29930 return nativeResponseValue;
29932 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
29934 export function Ping_set_ponglen(this_ptr: bigint, val: number): void {
29935 if(!isWasmInitialized) {
29936 throw new Error("initializeWasm() must be awaited first!");
29938 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
29939 // debug statements here
29941 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
29943 export function Ping_get_byteslen(this_ptr: bigint): number {
29944 if(!isWasmInitialized) {
29945 throw new Error("initializeWasm() must be awaited first!");
29947 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
29948 return nativeResponseValue;
29950 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
29952 export function Ping_set_byteslen(this_ptr: bigint, val: number): void {
29953 if(!isWasmInitialized) {
29954 throw new Error("initializeWasm() must be awaited first!");
29956 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
29957 // debug statements here
29959 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
29961 export function Ping_new(ponglen_arg: number, byteslen_arg: number): bigint {
29962 if(!isWasmInitialized) {
29963 throw new Error("initializeWasm() must be awaited first!");
29965 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
29966 return nativeResponseValue;
29968 // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
29970 export function Ping_clone_ptr(arg: bigint): bigint {
29971 if(!isWasmInitialized) {
29972 throw new Error("initializeWasm() must be awaited first!");
29974 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
29975 return nativeResponseValue;
29977 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
29979 export function Ping_clone(orig: bigint): bigint {
29980 if(!isWasmInitialized) {
29981 throw new Error("initializeWasm() must be awaited first!");
29983 const nativeResponseValue = wasm.TS_Ping_clone(orig);
29984 return nativeResponseValue;
29986 // bool Ping_eq(const struct LDKPing *NONNULL_PTR a, const struct LDKPing *NONNULL_PTR b);
29988 export function Ping_eq(a: bigint, b: bigint): boolean {
29989 if(!isWasmInitialized) {
29990 throw new Error("initializeWasm() must be awaited first!");
29992 const nativeResponseValue = wasm.TS_Ping_eq(a, b);
29993 return nativeResponseValue;
29995 // void Pong_free(struct LDKPong this_obj);
29997 export function Pong_free(this_obj: bigint): void {
29998 if(!isWasmInitialized) {
29999 throw new Error("initializeWasm() must be awaited first!");
30001 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
30002 // debug statements here
30004 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
30006 export function Pong_get_byteslen(this_ptr: bigint): number {
30007 if(!isWasmInitialized) {
30008 throw new Error("initializeWasm() must be awaited first!");
30010 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
30011 return nativeResponseValue;
30013 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
30015 export function Pong_set_byteslen(this_ptr: bigint, val: number): void {
30016 if(!isWasmInitialized) {
30017 throw new Error("initializeWasm() must be awaited first!");
30019 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
30020 // debug statements here
30022 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
30024 export function Pong_new(byteslen_arg: number): bigint {
30025 if(!isWasmInitialized) {
30026 throw new Error("initializeWasm() must be awaited first!");
30028 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
30029 return nativeResponseValue;
30031 // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
30033 export function Pong_clone_ptr(arg: bigint): bigint {
30034 if(!isWasmInitialized) {
30035 throw new Error("initializeWasm() must be awaited first!");
30037 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
30038 return nativeResponseValue;
30040 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
30042 export function Pong_clone(orig: bigint): bigint {
30043 if(!isWasmInitialized) {
30044 throw new Error("initializeWasm() must be awaited first!");
30046 const nativeResponseValue = wasm.TS_Pong_clone(orig);
30047 return nativeResponseValue;
30049 // bool Pong_eq(const struct LDKPong *NONNULL_PTR a, const struct LDKPong *NONNULL_PTR b);
30051 export function Pong_eq(a: bigint, b: bigint): boolean {
30052 if(!isWasmInitialized) {
30053 throw new Error("initializeWasm() must be awaited first!");
30055 const nativeResponseValue = wasm.TS_Pong_eq(a, b);
30056 return nativeResponseValue;
30058 // void OpenChannel_free(struct LDKOpenChannel this_obj);
30060 export function OpenChannel_free(this_obj: bigint): void {
30061 if(!isWasmInitialized) {
30062 throw new Error("initializeWasm() must be awaited first!");
30064 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
30065 // debug statements here
30067 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
30069 export function OpenChannel_get_chain_hash(this_ptr: bigint): number {
30070 if(!isWasmInitialized) {
30071 throw new Error("initializeWasm() must be awaited first!");
30073 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
30074 return nativeResponseValue;
30076 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30078 export function OpenChannel_set_chain_hash(this_ptr: bigint, val: number): void {
30079 if(!isWasmInitialized) {
30080 throw new Error("initializeWasm() must be awaited first!");
30082 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
30083 // debug statements here
30085 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
30087 export function OpenChannel_get_temporary_channel_id(this_ptr: bigint): number {
30088 if(!isWasmInitialized) {
30089 throw new Error("initializeWasm() must be awaited first!");
30091 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
30092 return nativeResponseValue;
30094 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30096 export function OpenChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
30097 if(!isWasmInitialized) {
30098 throw new Error("initializeWasm() must be awaited first!");
30100 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
30101 // debug statements here
30103 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30105 export function OpenChannel_get_funding_satoshis(this_ptr: bigint): bigint {
30106 if(!isWasmInitialized) {
30107 throw new Error("initializeWasm() must be awaited first!");
30109 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
30110 return nativeResponseValue;
30112 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
30114 export function OpenChannel_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
30115 if(!isWasmInitialized) {
30116 throw new Error("initializeWasm() must be awaited first!");
30118 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
30119 // debug statements here
30121 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30123 export function OpenChannel_get_push_msat(this_ptr: bigint): bigint {
30124 if(!isWasmInitialized) {
30125 throw new Error("initializeWasm() must be awaited first!");
30127 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
30128 return nativeResponseValue;
30130 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
30132 export function OpenChannel_set_push_msat(this_ptr: bigint, val: bigint): void {
30133 if(!isWasmInitialized) {
30134 throw new Error("initializeWasm() must be awaited first!");
30136 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
30137 // debug statements here
30139 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30141 export function OpenChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
30142 if(!isWasmInitialized) {
30143 throw new Error("initializeWasm() must be awaited first!");
30145 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
30146 return nativeResponseValue;
30148 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
30150 export function OpenChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
30151 if(!isWasmInitialized) {
30152 throw new Error("initializeWasm() must be awaited first!");
30154 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
30155 // debug statements here
30157 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30159 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
30160 if(!isWasmInitialized) {
30161 throw new Error("initializeWasm() must be awaited first!");
30163 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
30164 return nativeResponseValue;
30166 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
30168 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
30169 if(!isWasmInitialized) {
30170 throw new Error("initializeWasm() must be awaited first!");
30172 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
30173 // debug statements here
30175 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30177 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
30178 if(!isWasmInitialized) {
30179 throw new Error("initializeWasm() must be awaited first!");
30181 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
30182 return nativeResponseValue;
30184 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
30186 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
30187 if(!isWasmInitialized) {
30188 throw new Error("initializeWasm() must be awaited first!");
30190 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
30191 // debug statements here
30193 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30195 export function OpenChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
30196 if(!isWasmInitialized) {
30197 throw new Error("initializeWasm() must be awaited first!");
30199 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
30200 return nativeResponseValue;
30202 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
30204 export function OpenChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30205 if(!isWasmInitialized) {
30206 throw new Error("initializeWasm() must be awaited first!");
30208 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
30209 // debug statements here
30211 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30213 export function OpenChannel_get_feerate_per_kw(this_ptr: bigint): number {
30214 if(!isWasmInitialized) {
30215 throw new Error("initializeWasm() must be awaited first!");
30217 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
30218 return nativeResponseValue;
30220 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
30222 export function OpenChannel_set_feerate_per_kw(this_ptr: bigint, val: number): void {
30223 if(!isWasmInitialized) {
30224 throw new Error("initializeWasm() must be awaited first!");
30226 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
30227 // debug statements here
30229 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30231 export function OpenChannel_get_to_self_delay(this_ptr: bigint): number {
30232 if(!isWasmInitialized) {
30233 throw new Error("initializeWasm() must be awaited first!");
30235 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
30236 return nativeResponseValue;
30238 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
30240 export function OpenChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
30241 if(!isWasmInitialized) {
30242 throw new Error("initializeWasm() must be awaited first!");
30244 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
30245 // debug statements here
30247 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30249 export function OpenChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
30250 if(!isWasmInitialized) {
30251 throw new Error("initializeWasm() must be awaited first!");
30253 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
30254 return nativeResponseValue;
30256 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
30258 export function OpenChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
30259 if(!isWasmInitialized) {
30260 throw new Error("initializeWasm() must be awaited first!");
30262 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
30263 // debug statements here
30265 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30267 export function OpenChannel_get_funding_pubkey(this_ptr: bigint): number {
30268 if(!isWasmInitialized) {
30269 throw new Error("initializeWasm() must be awaited first!");
30271 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
30272 return nativeResponseValue;
30274 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30276 export function OpenChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
30277 if(!isWasmInitialized) {
30278 throw new Error("initializeWasm() must be awaited first!");
30280 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
30281 // debug statements here
30283 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30285 export function OpenChannel_get_revocation_basepoint(this_ptr: bigint): number {
30286 if(!isWasmInitialized) {
30287 throw new Error("initializeWasm() must be awaited first!");
30289 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
30290 return nativeResponseValue;
30292 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30294 export function OpenChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
30295 if(!isWasmInitialized) {
30296 throw new Error("initializeWasm() must be awaited first!");
30298 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
30299 // debug statements here
30301 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30303 export function OpenChannel_get_payment_point(this_ptr: bigint): number {
30304 if(!isWasmInitialized) {
30305 throw new Error("initializeWasm() must be awaited first!");
30307 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
30308 return nativeResponseValue;
30310 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30312 export function OpenChannel_set_payment_point(this_ptr: bigint, val: number): void {
30313 if(!isWasmInitialized) {
30314 throw new Error("initializeWasm() must be awaited first!");
30316 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
30317 // debug statements here
30319 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30321 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
30322 if(!isWasmInitialized) {
30323 throw new Error("initializeWasm() must be awaited first!");
30325 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
30326 return nativeResponseValue;
30328 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30330 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
30331 if(!isWasmInitialized) {
30332 throw new Error("initializeWasm() must be awaited first!");
30334 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
30335 // debug statements here
30337 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30339 export function OpenChannel_get_htlc_basepoint(this_ptr: bigint): number {
30340 if(!isWasmInitialized) {
30341 throw new Error("initializeWasm() must be awaited first!");
30343 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
30344 return nativeResponseValue;
30346 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30348 export function OpenChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
30349 if(!isWasmInitialized) {
30350 throw new Error("initializeWasm() must be awaited first!");
30352 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
30353 // debug statements here
30355 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30357 export function OpenChannel_get_first_per_commitment_point(this_ptr: bigint): number {
30358 if(!isWasmInitialized) {
30359 throw new Error("initializeWasm() must be awaited first!");
30361 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
30362 return nativeResponseValue;
30364 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30366 export function OpenChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
30367 if(!isWasmInitialized) {
30368 throw new Error("initializeWasm() must be awaited first!");
30370 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
30371 // debug statements here
30373 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30375 export function OpenChannel_get_channel_flags(this_ptr: bigint): number {
30376 if(!isWasmInitialized) {
30377 throw new Error("initializeWasm() must be awaited first!");
30379 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
30380 return nativeResponseValue;
30382 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
30384 export function OpenChannel_set_channel_flags(this_ptr: bigint, val: number): void {
30385 if(!isWasmInitialized) {
30386 throw new Error("initializeWasm() must be awaited first!");
30388 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
30389 // debug statements here
30391 // struct LDKCOption_CVec_u8ZZ OpenChannel_get_shutdown_scriptpubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30393 export function OpenChannel_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
30394 if(!isWasmInitialized) {
30395 throw new Error("initializeWasm() must be awaited first!");
30397 const nativeResponseValue = wasm.TS_OpenChannel_get_shutdown_scriptpubkey(this_ptr);
30398 return nativeResponseValue;
30400 // void OpenChannel_set_shutdown_scriptpubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
30402 export function OpenChannel_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
30403 if(!isWasmInitialized) {
30404 throw new Error("initializeWasm() must be awaited first!");
30406 const nativeResponseValue = wasm.TS_OpenChannel_set_shutdown_scriptpubkey(this_ptr, val);
30407 // debug statements here
30409 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
30411 export function OpenChannel_get_channel_type(this_ptr: bigint): bigint {
30412 if(!isWasmInitialized) {
30413 throw new Error("initializeWasm() must be awaited first!");
30415 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
30416 return nativeResponseValue;
30418 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
30420 export function OpenChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
30421 if(!isWasmInitialized) {
30422 throw new Error("initializeWasm() must be awaited first!");
30424 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
30425 // debug statements here
30427 // MUST_USE_RES struct LDKOpenChannel OpenChannel_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKThirtyTwoBytes temporary_channel_id_arg, uint64_t funding_satoshis_arg, uint64_t push_msat_arg, uint64_t dust_limit_satoshis_arg, uint64_t max_htlc_value_in_flight_msat_arg, uint64_t channel_reserve_satoshis_arg, uint64_t htlc_minimum_msat_arg, uint32_t feerate_per_kw_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_point_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);
30429 export function OpenChannel_new(chain_hash_arg: number, temporary_channel_id_arg: number, funding_satoshis_arg: bigint, push_msat_arg: bigint, dust_limit_satoshis_arg: bigint, max_htlc_value_in_flight_msat_arg: bigint, channel_reserve_satoshis_arg: bigint, htlc_minimum_msat_arg: bigint, feerate_per_kw_arg: number, to_self_delay_arg: number, max_accepted_htlcs_arg: number, funding_pubkey_arg: number, revocation_basepoint_arg: number, payment_point_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 {
30430 if(!isWasmInitialized) {
30431 throw new Error("initializeWasm() must be awaited first!");
30433 const nativeResponseValue = wasm.TS_OpenChannel_new(chain_hash_arg, temporary_channel_id_arg, funding_satoshis_arg, push_msat_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, channel_reserve_satoshis_arg, htlc_minimum_msat_arg, feerate_per_kw_arg, to_self_delay_arg, max_accepted_htlcs_arg, funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg, first_per_commitment_point_arg, channel_flags_arg, shutdown_scriptpubkey_arg, channel_type_arg);
30434 return nativeResponseValue;
30436 // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
30438 export function OpenChannel_clone_ptr(arg: bigint): bigint {
30439 if(!isWasmInitialized) {
30440 throw new Error("initializeWasm() must be awaited first!");
30442 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
30443 return nativeResponseValue;
30445 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
30447 export function OpenChannel_clone(orig: bigint): bigint {
30448 if(!isWasmInitialized) {
30449 throw new Error("initializeWasm() must be awaited first!");
30451 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
30452 return nativeResponseValue;
30454 // bool OpenChannel_eq(const struct LDKOpenChannel *NONNULL_PTR a, const struct LDKOpenChannel *NONNULL_PTR b);
30456 export function OpenChannel_eq(a: bigint, b: bigint): boolean {
30457 if(!isWasmInitialized) {
30458 throw new Error("initializeWasm() must be awaited first!");
30460 const nativeResponseValue = wasm.TS_OpenChannel_eq(a, b);
30461 return nativeResponseValue;
30463 // void OpenChannelV2_free(struct LDKOpenChannelV2 this_obj);
30465 export function OpenChannelV2_free(this_obj: bigint): void {
30466 if(!isWasmInitialized) {
30467 throw new Error("initializeWasm() must be awaited first!");
30469 const nativeResponseValue = wasm.TS_OpenChannelV2_free(this_obj);
30470 // debug statements here
30472 // const uint8_t (*OpenChannelV2_get_chain_hash(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr))[32];
30474 export function OpenChannelV2_get_chain_hash(this_ptr: bigint): number {
30475 if(!isWasmInitialized) {
30476 throw new Error("initializeWasm() must be awaited first!");
30478 const nativeResponseValue = wasm.TS_OpenChannelV2_get_chain_hash(this_ptr);
30479 return nativeResponseValue;
30481 // void OpenChannelV2_set_chain_hash(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30483 export function OpenChannelV2_set_chain_hash(this_ptr: bigint, val: number): void {
30484 if(!isWasmInitialized) {
30485 throw new Error("initializeWasm() must be awaited first!");
30487 const nativeResponseValue = wasm.TS_OpenChannelV2_set_chain_hash(this_ptr, val);
30488 // debug statements here
30490 // const uint8_t (*OpenChannelV2_get_temporary_channel_id(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr))[32];
30492 export function OpenChannelV2_get_temporary_channel_id(this_ptr: bigint): number {
30493 if(!isWasmInitialized) {
30494 throw new Error("initializeWasm() must be awaited first!");
30496 const nativeResponseValue = wasm.TS_OpenChannelV2_get_temporary_channel_id(this_ptr);
30497 return nativeResponseValue;
30499 // void OpenChannelV2_set_temporary_channel_id(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30501 export function OpenChannelV2_set_temporary_channel_id(this_ptr: bigint, val: number): void {
30502 if(!isWasmInitialized) {
30503 throw new Error("initializeWasm() must be awaited first!");
30505 const nativeResponseValue = wasm.TS_OpenChannelV2_set_temporary_channel_id(this_ptr, val);
30506 // debug statements here
30508 // uint32_t OpenChannelV2_get_funding_feerate_sat_per_1000_weight(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30510 export function OpenChannelV2_get_funding_feerate_sat_per_1000_weight(this_ptr: bigint): number {
30511 if(!isWasmInitialized) {
30512 throw new Error("initializeWasm() must be awaited first!");
30514 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_feerate_sat_per_1000_weight(this_ptr);
30515 return nativeResponseValue;
30517 // void OpenChannelV2_set_funding_feerate_sat_per_1000_weight(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
30519 export function OpenChannelV2_set_funding_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
30520 if(!isWasmInitialized) {
30521 throw new Error("initializeWasm() must be awaited first!");
30523 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_feerate_sat_per_1000_weight(this_ptr, val);
30524 // debug statements here
30526 // uint32_t OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30528 export function OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(this_ptr: bigint): number {
30529 if(!isWasmInitialized) {
30530 throw new Error("initializeWasm() must be awaited first!");
30532 const nativeResponseValue = wasm.TS_OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(this_ptr);
30533 return nativeResponseValue;
30535 // void OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
30537 export function OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
30538 if(!isWasmInitialized) {
30539 throw new Error("initializeWasm() must be awaited first!");
30541 const nativeResponseValue = wasm.TS_OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(this_ptr, val);
30542 // debug statements here
30544 // uint64_t OpenChannelV2_get_funding_satoshis(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30546 export function OpenChannelV2_get_funding_satoshis(this_ptr: bigint): bigint {
30547 if(!isWasmInitialized) {
30548 throw new Error("initializeWasm() must be awaited first!");
30550 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_satoshis(this_ptr);
30551 return nativeResponseValue;
30553 // void OpenChannelV2_set_funding_satoshis(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30555 export function OpenChannelV2_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
30556 if(!isWasmInitialized) {
30557 throw new Error("initializeWasm() must be awaited first!");
30559 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_satoshis(this_ptr, val);
30560 // debug statements here
30562 // uint64_t OpenChannelV2_get_dust_limit_satoshis(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30564 export function OpenChannelV2_get_dust_limit_satoshis(this_ptr: bigint): bigint {
30565 if(!isWasmInitialized) {
30566 throw new Error("initializeWasm() must be awaited first!");
30568 const nativeResponseValue = wasm.TS_OpenChannelV2_get_dust_limit_satoshis(this_ptr);
30569 return nativeResponseValue;
30571 // void OpenChannelV2_set_dust_limit_satoshis(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30573 export function OpenChannelV2_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
30574 if(!isWasmInitialized) {
30575 throw new Error("initializeWasm() must be awaited first!");
30577 const nativeResponseValue = wasm.TS_OpenChannelV2_set_dust_limit_satoshis(this_ptr, val);
30578 // debug statements here
30580 // uint64_t OpenChannelV2_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30582 export function OpenChannelV2_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
30583 if(!isWasmInitialized) {
30584 throw new Error("initializeWasm() must be awaited first!");
30586 const nativeResponseValue = wasm.TS_OpenChannelV2_get_max_htlc_value_in_flight_msat(this_ptr);
30587 return nativeResponseValue;
30589 // void OpenChannelV2_set_max_htlc_value_in_flight_msat(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30591 export function OpenChannelV2_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
30592 if(!isWasmInitialized) {
30593 throw new Error("initializeWasm() must be awaited first!");
30595 const nativeResponseValue = wasm.TS_OpenChannelV2_set_max_htlc_value_in_flight_msat(this_ptr, val);
30596 // debug statements here
30598 // uint64_t OpenChannelV2_get_htlc_minimum_msat(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30600 export function OpenChannelV2_get_htlc_minimum_msat(this_ptr: bigint): bigint {
30601 if(!isWasmInitialized) {
30602 throw new Error("initializeWasm() must be awaited first!");
30604 const nativeResponseValue = wasm.TS_OpenChannelV2_get_htlc_minimum_msat(this_ptr);
30605 return nativeResponseValue;
30607 // void OpenChannelV2_set_htlc_minimum_msat(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
30609 export function OpenChannelV2_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30610 if(!isWasmInitialized) {
30611 throw new Error("initializeWasm() must be awaited first!");
30613 const nativeResponseValue = wasm.TS_OpenChannelV2_set_htlc_minimum_msat(this_ptr, val);
30614 // debug statements here
30616 // uint16_t OpenChannelV2_get_to_self_delay(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30618 export function OpenChannelV2_get_to_self_delay(this_ptr: bigint): number {
30619 if(!isWasmInitialized) {
30620 throw new Error("initializeWasm() must be awaited first!");
30622 const nativeResponseValue = wasm.TS_OpenChannelV2_get_to_self_delay(this_ptr);
30623 return nativeResponseValue;
30625 // void OpenChannelV2_set_to_self_delay(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
30627 export function OpenChannelV2_set_to_self_delay(this_ptr: bigint, val: number): void {
30628 if(!isWasmInitialized) {
30629 throw new Error("initializeWasm() must be awaited first!");
30631 const nativeResponseValue = wasm.TS_OpenChannelV2_set_to_self_delay(this_ptr, val);
30632 // debug statements here
30634 // uint16_t OpenChannelV2_get_max_accepted_htlcs(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30636 export function OpenChannelV2_get_max_accepted_htlcs(this_ptr: bigint): number {
30637 if(!isWasmInitialized) {
30638 throw new Error("initializeWasm() must be awaited first!");
30640 const nativeResponseValue = wasm.TS_OpenChannelV2_get_max_accepted_htlcs(this_ptr);
30641 return nativeResponseValue;
30643 // void OpenChannelV2_set_max_accepted_htlcs(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
30645 export function OpenChannelV2_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
30646 if(!isWasmInitialized) {
30647 throw new Error("initializeWasm() must be awaited first!");
30649 const nativeResponseValue = wasm.TS_OpenChannelV2_set_max_accepted_htlcs(this_ptr, val);
30650 // debug statements here
30652 // uint32_t OpenChannelV2_get_locktime(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30654 export function OpenChannelV2_get_locktime(this_ptr: bigint): number {
30655 if(!isWasmInitialized) {
30656 throw new Error("initializeWasm() must be awaited first!");
30658 const nativeResponseValue = wasm.TS_OpenChannelV2_get_locktime(this_ptr);
30659 return nativeResponseValue;
30661 // void OpenChannelV2_set_locktime(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
30663 export function OpenChannelV2_set_locktime(this_ptr: bigint, val: number): void {
30664 if(!isWasmInitialized) {
30665 throw new Error("initializeWasm() must be awaited first!");
30667 const nativeResponseValue = wasm.TS_OpenChannelV2_set_locktime(this_ptr, val);
30668 // debug statements here
30670 // struct LDKPublicKey OpenChannelV2_get_funding_pubkey(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30672 export function OpenChannelV2_get_funding_pubkey(this_ptr: bigint): number {
30673 if(!isWasmInitialized) {
30674 throw new Error("initializeWasm() must be awaited first!");
30676 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_pubkey(this_ptr);
30677 return nativeResponseValue;
30679 // void OpenChannelV2_set_funding_pubkey(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30681 export function OpenChannelV2_set_funding_pubkey(this_ptr: bigint, val: number): void {
30682 if(!isWasmInitialized) {
30683 throw new Error("initializeWasm() must be awaited first!");
30685 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_pubkey(this_ptr, val);
30686 // debug statements here
30688 // struct LDKPublicKey OpenChannelV2_get_revocation_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30690 export function OpenChannelV2_get_revocation_basepoint(this_ptr: bigint): number {
30691 if(!isWasmInitialized) {
30692 throw new Error("initializeWasm() must be awaited first!");
30694 const nativeResponseValue = wasm.TS_OpenChannelV2_get_revocation_basepoint(this_ptr);
30695 return nativeResponseValue;
30697 // void OpenChannelV2_set_revocation_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30699 export function OpenChannelV2_set_revocation_basepoint(this_ptr: bigint, val: number): void {
30700 if(!isWasmInitialized) {
30701 throw new Error("initializeWasm() must be awaited first!");
30703 const nativeResponseValue = wasm.TS_OpenChannelV2_set_revocation_basepoint(this_ptr, val);
30704 // debug statements here
30706 // struct LDKPublicKey OpenChannelV2_get_payment_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30708 export function OpenChannelV2_get_payment_basepoint(this_ptr: bigint): number {
30709 if(!isWasmInitialized) {
30710 throw new Error("initializeWasm() must be awaited first!");
30712 const nativeResponseValue = wasm.TS_OpenChannelV2_get_payment_basepoint(this_ptr);
30713 return nativeResponseValue;
30715 // void OpenChannelV2_set_payment_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30717 export function OpenChannelV2_set_payment_basepoint(this_ptr: bigint, val: number): void {
30718 if(!isWasmInitialized) {
30719 throw new Error("initializeWasm() must be awaited first!");
30721 const nativeResponseValue = wasm.TS_OpenChannelV2_set_payment_basepoint(this_ptr, val);
30722 // debug statements here
30724 // struct LDKPublicKey OpenChannelV2_get_delayed_payment_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30726 export function OpenChannelV2_get_delayed_payment_basepoint(this_ptr: bigint): number {
30727 if(!isWasmInitialized) {
30728 throw new Error("initializeWasm() must be awaited first!");
30730 const nativeResponseValue = wasm.TS_OpenChannelV2_get_delayed_payment_basepoint(this_ptr);
30731 return nativeResponseValue;
30733 // void OpenChannelV2_set_delayed_payment_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30735 export function OpenChannelV2_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
30736 if(!isWasmInitialized) {
30737 throw new Error("initializeWasm() must be awaited first!");
30739 const nativeResponseValue = wasm.TS_OpenChannelV2_set_delayed_payment_basepoint(this_ptr, val);
30740 // debug statements here
30742 // struct LDKPublicKey OpenChannelV2_get_htlc_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30744 export function OpenChannelV2_get_htlc_basepoint(this_ptr: bigint): number {
30745 if(!isWasmInitialized) {
30746 throw new Error("initializeWasm() must be awaited first!");
30748 const nativeResponseValue = wasm.TS_OpenChannelV2_get_htlc_basepoint(this_ptr);
30749 return nativeResponseValue;
30751 // void OpenChannelV2_set_htlc_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30753 export function OpenChannelV2_set_htlc_basepoint(this_ptr: bigint, val: number): void {
30754 if(!isWasmInitialized) {
30755 throw new Error("initializeWasm() must be awaited first!");
30757 const nativeResponseValue = wasm.TS_OpenChannelV2_set_htlc_basepoint(this_ptr, val);
30758 // debug statements here
30760 // struct LDKPublicKey OpenChannelV2_get_first_per_commitment_point(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30762 export function OpenChannelV2_get_first_per_commitment_point(this_ptr: bigint): number {
30763 if(!isWasmInitialized) {
30764 throw new Error("initializeWasm() must be awaited first!");
30766 const nativeResponseValue = wasm.TS_OpenChannelV2_get_first_per_commitment_point(this_ptr);
30767 return nativeResponseValue;
30769 // void OpenChannelV2_set_first_per_commitment_point(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30771 export function OpenChannelV2_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
30772 if(!isWasmInitialized) {
30773 throw new Error("initializeWasm() must be awaited first!");
30775 const nativeResponseValue = wasm.TS_OpenChannelV2_set_first_per_commitment_point(this_ptr, val);
30776 // debug statements here
30778 // struct LDKPublicKey OpenChannelV2_get_second_per_commitment_point(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30780 export function OpenChannelV2_get_second_per_commitment_point(this_ptr: bigint): number {
30781 if(!isWasmInitialized) {
30782 throw new Error("initializeWasm() must be awaited first!");
30784 const nativeResponseValue = wasm.TS_OpenChannelV2_get_second_per_commitment_point(this_ptr);
30785 return nativeResponseValue;
30787 // void OpenChannelV2_set_second_per_commitment_point(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30789 export function OpenChannelV2_set_second_per_commitment_point(this_ptr: bigint, val: number): void {
30790 if(!isWasmInitialized) {
30791 throw new Error("initializeWasm() must be awaited first!");
30793 const nativeResponseValue = wasm.TS_OpenChannelV2_set_second_per_commitment_point(this_ptr, val);
30794 // debug statements here
30796 // uint8_t OpenChannelV2_get_channel_flags(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30798 export function OpenChannelV2_get_channel_flags(this_ptr: bigint): number {
30799 if(!isWasmInitialized) {
30800 throw new Error("initializeWasm() must be awaited first!");
30802 const nativeResponseValue = wasm.TS_OpenChannelV2_get_channel_flags(this_ptr);
30803 return nativeResponseValue;
30805 // void OpenChannelV2_set_channel_flags(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint8_t val);
30807 export function OpenChannelV2_set_channel_flags(this_ptr: bigint, val: number): void {
30808 if(!isWasmInitialized) {
30809 throw new Error("initializeWasm() must be awaited first!");
30811 const nativeResponseValue = wasm.TS_OpenChannelV2_set_channel_flags(this_ptr, val);
30812 // debug statements here
30814 // struct LDKCOption_CVec_u8ZZ OpenChannelV2_get_shutdown_scriptpubkey(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30816 export function OpenChannelV2_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
30817 if(!isWasmInitialized) {
30818 throw new Error("initializeWasm() must be awaited first!");
30820 const nativeResponseValue = wasm.TS_OpenChannelV2_get_shutdown_scriptpubkey(this_ptr);
30821 return nativeResponseValue;
30823 // void OpenChannelV2_set_shutdown_scriptpubkey(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
30825 export function OpenChannelV2_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
30826 if(!isWasmInitialized) {
30827 throw new Error("initializeWasm() must be awaited first!");
30829 const nativeResponseValue = wasm.TS_OpenChannelV2_set_shutdown_scriptpubkey(this_ptr, val);
30830 // debug statements here
30832 // struct LDKChannelTypeFeatures OpenChannelV2_get_channel_type(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30834 export function OpenChannelV2_get_channel_type(this_ptr: bigint): bigint {
30835 if(!isWasmInitialized) {
30836 throw new Error("initializeWasm() must be awaited first!");
30838 const nativeResponseValue = wasm.TS_OpenChannelV2_get_channel_type(this_ptr);
30839 return nativeResponseValue;
30841 // void OpenChannelV2_set_channel_type(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
30843 export function OpenChannelV2_set_channel_type(this_ptr: bigint, val: bigint): void {
30844 if(!isWasmInitialized) {
30845 throw new Error("initializeWasm() must be awaited first!");
30847 const nativeResponseValue = wasm.TS_OpenChannelV2_set_channel_type(this_ptr, val);
30848 // debug statements here
30850 // enum LDKCOption_NoneZ OpenChannelV2_get_require_confirmed_inputs(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
30852 export function OpenChannelV2_get_require_confirmed_inputs(this_ptr: bigint): COption_NoneZ {
30853 if(!isWasmInitialized) {
30854 throw new Error("initializeWasm() must be awaited first!");
30856 const nativeResponseValue = wasm.TS_OpenChannelV2_get_require_confirmed_inputs(this_ptr);
30857 return nativeResponseValue;
30859 // void OpenChannelV2_set_require_confirmed_inputs(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
30861 export function OpenChannelV2_set_require_confirmed_inputs(this_ptr: bigint, val: COption_NoneZ): void {
30862 if(!isWasmInitialized) {
30863 throw new Error("initializeWasm() must be awaited first!");
30865 const nativeResponseValue = wasm.TS_OpenChannelV2_set_require_confirmed_inputs(this_ptr, val);
30866 // debug statements here
30868 // MUST_USE_RES struct LDKOpenChannelV2 OpenChannelV2_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKThirtyTwoBytes temporary_channel_id_arg, uint32_t funding_feerate_sat_per_1000_weight_arg, uint32_t commitment_feerate_sat_per_1000_weight_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, uint16_t to_self_delay_arg, uint16_t max_accepted_htlcs_arg, uint32_t locktime_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 LDKPublicKey second_per_commitment_point_arg, uint8_t channel_flags_arg, struct LDKCOption_CVec_u8ZZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg, enum LDKCOption_NoneZ require_confirmed_inputs_arg);
30870 export function OpenChannelV2_new(chain_hash_arg: number, temporary_channel_id_arg: number, funding_feerate_sat_per_1000_weight_arg: number, commitment_feerate_sat_per_1000_weight_arg: number, funding_satoshis_arg: bigint, dust_limit_satoshis_arg: bigint, max_htlc_value_in_flight_msat_arg: bigint, htlc_minimum_msat_arg: bigint, to_self_delay_arg: number, max_accepted_htlcs_arg: number, locktime_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, second_per_commitment_point_arg: number, channel_flags_arg: number, shutdown_scriptpubkey_arg: bigint, channel_type_arg: bigint, require_confirmed_inputs_arg: COption_NoneZ): bigint {
30871 if(!isWasmInitialized) {
30872 throw new Error("initializeWasm() must be awaited first!");
30874 const nativeResponseValue = wasm.TS_OpenChannelV2_new(chain_hash_arg, temporary_channel_id_arg, funding_feerate_sat_per_1000_weight_arg, commitment_feerate_sat_per_1000_weight_arg, funding_satoshis_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, htlc_minimum_msat_arg, to_self_delay_arg, max_accepted_htlcs_arg, locktime_arg, funding_pubkey_arg, revocation_basepoint_arg, payment_basepoint_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg, first_per_commitment_point_arg, second_per_commitment_point_arg, channel_flags_arg, shutdown_scriptpubkey_arg, channel_type_arg, require_confirmed_inputs_arg);
30875 return nativeResponseValue;
30877 // uint64_t OpenChannelV2_clone_ptr(LDKOpenChannelV2 *NONNULL_PTR arg);
30879 export function OpenChannelV2_clone_ptr(arg: bigint): bigint {
30880 if(!isWasmInitialized) {
30881 throw new Error("initializeWasm() must be awaited first!");
30883 const nativeResponseValue = wasm.TS_OpenChannelV2_clone_ptr(arg);
30884 return nativeResponseValue;
30886 // struct LDKOpenChannelV2 OpenChannelV2_clone(const struct LDKOpenChannelV2 *NONNULL_PTR orig);
30888 export function OpenChannelV2_clone(orig: bigint): bigint {
30889 if(!isWasmInitialized) {
30890 throw new Error("initializeWasm() must be awaited first!");
30892 const nativeResponseValue = wasm.TS_OpenChannelV2_clone(orig);
30893 return nativeResponseValue;
30895 // bool OpenChannelV2_eq(const struct LDKOpenChannelV2 *NONNULL_PTR a, const struct LDKOpenChannelV2 *NONNULL_PTR b);
30897 export function OpenChannelV2_eq(a: bigint, b: bigint): boolean {
30898 if(!isWasmInitialized) {
30899 throw new Error("initializeWasm() must be awaited first!");
30901 const nativeResponseValue = wasm.TS_OpenChannelV2_eq(a, b);
30902 return nativeResponseValue;
30904 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
30906 export function AcceptChannel_free(this_obj: bigint): void {
30907 if(!isWasmInitialized) {
30908 throw new Error("initializeWasm() must be awaited first!");
30910 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
30911 // debug statements here
30913 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
30915 export function AcceptChannel_get_temporary_channel_id(this_ptr: bigint): number {
30916 if(!isWasmInitialized) {
30917 throw new Error("initializeWasm() must be awaited first!");
30919 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
30920 return nativeResponseValue;
30922 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30924 export function AcceptChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
30925 if(!isWasmInitialized) {
30926 throw new Error("initializeWasm() must be awaited first!");
30928 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
30929 // debug statements here
30931 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30933 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
30934 if(!isWasmInitialized) {
30935 throw new Error("initializeWasm() must be awaited first!");
30937 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
30938 return nativeResponseValue;
30940 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
30942 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
30943 if(!isWasmInitialized) {
30944 throw new Error("initializeWasm() must be awaited first!");
30946 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
30947 // debug statements here
30949 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30951 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
30952 if(!isWasmInitialized) {
30953 throw new Error("initializeWasm() must be awaited first!");
30955 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
30956 return nativeResponseValue;
30958 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
30960 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
30961 if(!isWasmInitialized) {
30962 throw new Error("initializeWasm() must be awaited first!");
30964 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
30965 // debug statements here
30967 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30969 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
30970 if(!isWasmInitialized) {
30971 throw new Error("initializeWasm() must be awaited first!");
30973 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
30974 return nativeResponseValue;
30976 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
30978 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
30979 if(!isWasmInitialized) {
30980 throw new Error("initializeWasm() must be awaited first!");
30982 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
30983 // debug statements here
30985 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
30987 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
30988 if(!isWasmInitialized) {
30989 throw new Error("initializeWasm() must be awaited first!");
30991 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
30992 return nativeResponseValue;
30994 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
30996 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30997 if(!isWasmInitialized) {
30998 throw new Error("initializeWasm() must be awaited first!");
31000 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
31001 // debug statements here
31003 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
31005 export function AcceptChannel_get_minimum_depth(this_ptr: bigint): number {
31006 if(!isWasmInitialized) {
31007 throw new Error("initializeWasm() must be awaited first!");
31009 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
31010 return nativeResponseValue;
31012 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
31014 export function AcceptChannel_set_minimum_depth(this_ptr: bigint, val: number): void {
31015 if(!isWasmInitialized) {
31016 throw new Error("initializeWasm() must be awaited first!");
31018 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
31019 // debug statements here
31021 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
31023 export function AcceptChannel_get_to_self_delay(this_ptr: bigint): number {
31024 if(!isWasmInitialized) {
31025 throw new Error("initializeWasm() must be awaited first!");
31027 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
31028 return nativeResponseValue;
31030 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
31032 export function AcceptChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
31033 if(!isWasmInitialized) {
31034 throw new Error("initializeWasm() must be awaited first!");
31036 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
31037 // debug statements here
31039 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
31041 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
31042 if(!isWasmInitialized) {
31043 throw new Error("initializeWasm() must be awaited first!");
31045 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
31046 return nativeResponseValue;
31048 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
31050 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
31051 if(!isWasmInitialized) {
31052 throw new Error("initializeWasm() must be awaited first!");
31054 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
31055 // debug statements here
31057 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
31059 export function AcceptChannel_get_funding_pubkey(this_ptr: bigint): number {
31060 if(!isWasmInitialized) {
31061 throw new Error("initializeWasm() must be awaited first!");
31063 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
31064 return nativeResponseValue;
31066 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31068 export function AcceptChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
31069 if(!isWasmInitialized) {
31070 throw new Error("initializeWasm() must be awaited first!");
31072 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
31073 // debug statements here
31075 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
31077 export function AcceptChannel_get_revocation_basepoint(this_ptr: bigint): number {
31078 if(!isWasmInitialized) {
31079 throw new Error("initializeWasm() must be awaited first!");
31081 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
31082 return nativeResponseValue;
31084 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31086 export function AcceptChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
31087 if(!isWasmInitialized) {
31088 throw new Error("initializeWasm() must be awaited first!");
31090 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
31091 // debug statements here
31093 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
31095 export function AcceptChannel_get_payment_point(this_ptr: bigint): number {
31096 if(!isWasmInitialized) {
31097 throw new Error("initializeWasm() must be awaited first!");
31099 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
31100 return nativeResponseValue;
31102 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31104 export function AcceptChannel_set_payment_point(this_ptr: bigint, val: number): void {
31105 if(!isWasmInitialized) {
31106 throw new Error("initializeWasm() must be awaited first!");
31108 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
31109 // debug statements here
31111 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
31113 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
31114 if(!isWasmInitialized) {
31115 throw new Error("initializeWasm() must be awaited first!");
31117 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
31118 return nativeResponseValue;
31120 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31122 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
31123 if(!isWasmInitialized) {
31124 throw new Error("initializeWasm() must be awaited first!");
31126 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
31127 // debug statements here
31129 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
31131 export function AcceptChannel_get_htlc_basepoint(this_ptr: bigint): number {
31132 if(!isWasmInitialized) {
31133 throw new Error("initializeWasm() must be awaited first!");
31135 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
31136 return nativeResponseValue;
31138 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31140 export function AcceptChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
31141 if(!isWasmInitialized) {
31142 throw new Error("initializeWasm() must be awaited first!");
31144 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
31145 // debug statements here
31147 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
31149 export function AcceptChannel_get_first_per_commitment_point(this_ptr: bigint): number {
31150 if(!isWasmInitialized) {
31151 throw new Error("initializeWasm() must be awaited first!");
31153 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
31154 return nativeResponseValue;
31156 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31158 export function AcceptChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
31159 if(!isWasmInitialized) {
31160 throw new Error("initializeWasm() must be awaited first!");
31162 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
31163 // debug statements here
31165 // struct LDKCOption_CVec_u8ZZ AcceptChannel_get_shutdown_scriptpubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
31167 export function AcceptChannel_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
31168 if(!isWasmInitialized) {
31169 throw new Error("initializeWasm() must be awaited first!");
31171 const nativeResponseValue = wasm.TS_AcceptChannel_get_shutdown_scriptpubkey(this_ptr);
31172 return nativeResponseValue;
31174 // void AcceptChannel_set_shutdown_scriptpubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
31176 export function AcceptChannel_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
31177 if(!isWasmInitialized) {
31178 throw new Error("initializeWasm() must be awaited first!");
31180 const nativeResponseValue = wasm.TS_AcceptChannel_set_shutdown_scriptpubkey(this_ptr, val);
31181 // debug statements here
31183 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
31185 export function AcceptChannel_get_channel_type(this_ptr: bigint): bigint {
31186 if(!isWasmInitialized) {
31187 throw new Error("initializeWasm() must be awaited first!");
31189 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
31190 return nativeResponseValue;
31192 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
31194 export function AcceptChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
31195 if(!isWasmInitialized) {
31196 throw new Error("initializeWasm() must be awaited first!");
31198 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
31199 // debug statements here
31201 // MUST_USE_RES struct LDKAcceptChannel AcceptChannel_new(struct LDKThirtyTwoBytes temporary_channel_id_arg, uint64_t dust_limit_satoshis_arg, uint64_t max_htlc_value_in_flight_msat_arg, uint64_t channel_reserve_satoshis_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_point_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);
31203 export function AcceptChannel_new(temporary_channel_id_arg: number, dust_limit_satoshis_arg: bigint, max_htlc_value_in_flight_msat_arg: bigint, channel_reserve_satoshis_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_point_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 {
31204 if(!isWasmInitialized) {
31205 throw new Error("initializeWasm() must be awaited first!");
31207 const nativeResponseValue = wasm.TS_AcceptChannel_new(temporary_channel_id_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, channel_reserve_satoshis_arg, htlc_minimum_msat_arg, minimum_depth_arg, to_self_delay_arg, max_accepted_htlcs_arg, funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg, first_per_commitment_point_arg, shutdown_scriptpubkey_arg, channel_type_arg);
31208 return nativeResponseValue;
31210 // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
31212 export function AcceptChannel_clone_ptr(arg: bigint): bigint {
31213 if(!isWasmInitialized) {
31214 throw new Error("initializeWasm() must be awaited first!");
31216 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
31217 return nativeResponseValue;
31219 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
31221 export function AcceptChannel_clone(orig: bigint): bigint {
31222 if(!isWasmInitialized) {
31223 throw new Error("initializeWasm() must be awaited first!");
31225 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
31226 return nativeResponseValue;
31228 // bool AcceptChannel_eq(const struct LDKAcceptChannel *NONNULL_PTR a, const struct LDKAcceptChannel *NONNULL_PTR b);
31230 export function AcceptChannel_eq(a: bigint, b: bigint): boolean {
31231 if(!isWasmInitialized) {
31232 throw new Error("initializeWasm() must be awaited first!");
31234 const nativeResponseValue = wasm.TS_AcceptChannel_eq(a, b);
31235 return nativeResponseValue;
31237 // void AcceptChannelV2_free(struct LDKAcceptChannelV2 this_obj);
31239 export function AcceptChannelV2_free(this_obj: bigint): void {
31240 if(!isWasmInitialized) {
31241 throw new Error("initializeWasm() must be awaited first!");
31243 const nativeResponseValue = wasm.TS_AcceptChannelV2_free(this_obj);
31244 // debug statements here
31246 // const uint8_t (*AcceptChannelV2_get_temporary_channel_id(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr))[32];
31248 export function AcceptChannelV2_get_temporary_channel_id(this_ptr: bigint): number {
31249 if(!isWasmInitialized) {
31250 throw new Error("initializeWasm() must be awaited first!");
31252 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_temporary_channel_id(this_ptr);
31253 return nativeResponseValue;
31255 // void AcceptChannelV2_set_temporary_channel_id(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31257 export function AcceptChannelV2_set_temporary_channel_id(this_ptr: bigint, val: number): void {
31258 if(!isWasmInitialized) {
31259 throw new Error("initializeWasm() must be awaited first!");
31261 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_temporary_channel_id(this_ptr, val);
31262 // debug statements here
31264 // uint64_t AcceptChannelV2_get_funding_satoshis(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31266 export function AcceptChannelV2_get_funding_satoshis(this_ptr: bigint): bigint {
31267 if(!isWasmInitialized) {
31268 throw new Error("initializeWasm() must be awaited first!");
31270 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_funding_satoshis(this_ptr);
31271 return nativeResponseValue;
31273 // void AcceptChannelV2_set_funding_satoshis(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
31275 export function AcceptChannelV2_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
31276 if(!isWasmInitialized) {
31277 throw new Error("initializeWasm() must be awaited first!");
31279 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_funding_satoshis(this_ptr, val);
31280 // debug statements here
31282 // uint64_t AcceptChannelV2_get_dust_limit_satoshis(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31284 export function AcceptChannelV2_get_dust_limit_satoshis(this_ptr: bigint): bigint {
31285 if(!isWasmInitialized) {
31286 throw new Error("initializeWasm() must be awaited first!");
31288 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_dust_limit_satoshis(this_ptr);
31289 return nativeResponseValue;
31291 // void AcceptChannelV2_set_dust_limit_satoshis(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
31293 export function AcceptChannelV2_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
31294 if(!isWasmInitialized) {
31295 throw new Error("initializeWasm() must be awaited first!");
31297 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_dust_limit_satoshis(this_ptr, val);
31298 // debug statements here
31300 // uint64_t AcceptChannelV2_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31302 export function AcceptChannelV2_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
31303 if(!isWasmInitialized) {
31304 throw new Error("initializeWasm() must be awaited first!");
31306 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_max_htlc_value_in_flight_msat(this_ptr);
31307 return nativeResponseValue;
31309 // void AcceptChannelV2_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
31311 export function AcceptChannelV2_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
31312 if(!isWasmInitialized) {
31313 throw new Error("initializeWasm() must be awaited first!");
31315 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_max_htlc_value_in_flight_msat(this_ptr, val);
31316 // debug statements here
31318 // uint64_t AcceptChannelV2_get_htlc_minimum_msat(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31320 export function AcceptChannelV2_get_htlc_minimum_msat(this_ptr: bigint): bigint {
31321 if(!isWasmInitialized) {
31322 throw new Error("initializeWasm() must be awaited first!");
31324 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_htlc_minimum_msat(this_ptr);
31325 return nativeResponseValue;
31327 // void AcceptChannelV2_set_htlc_minimum_msat(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
31329 export function AcceptChannelV2_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
31330 if(!isWasmInitialized) {
31331 throw new Error("initializeWasm() must be awaited first!");
31333 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_htlc_minimum_msat(this_ptr, val);
31334 // debug statements here
31336 // uint32_t AcceptChannelV2_get_minimum_depth(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31338 export function AcceptChannelV2_get_minimum_depth(this_ptr: bigint): number {
31339 if(!isWasmInitialized) {
31340 throw new Error("initializeWasm() must be awaited first!");
31342 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_minimum_depth(this_ptr);
31343 return nativeResponseValue;
31345 // void AcceptChannelV2_set_minimum_depth(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
31347 export function AcceptChannelV2_set_minimum_depth(this_ptr: bigint, val: number): void {
31348 if(!isWasmInitialized) {
31349 throw new Error("initializeWasm() must be awaited first!");
31351 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_minimum_depth(this_ptr, val);
31352 // debug statements here
31354 // uint16_t AcceptChannelV2_get_to_self_delay(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31356 export function AcceptChannelV2_get_to_self_delay(this_ptr: bigint): number {
31357 if(!isWasmInitialized) {
31358 throw new Error("initializeWasm() must be awaited first!");
31360 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_to_self_delay(this_ptr);
31361 return nativeResponseValue;
31363 // void AcceptChannelV2_set_to_self_delay(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
31365 export function AcceptChannelV2_set_to_self_delay(this_ptr: bigint, val: number): void {
31366 if(!isWasmInitialized) {
31367 throw new Error("initializeWasm() must be awaited first!");
31369 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_to_self_delay(this_ptr, val);
31370 // debug statements here
31372 // uint16_t AcceptChannelV2_get_max_accepted_htlcs(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31374 export function AcceptChannelV2_get_max_accepted_htlcs(this_ptr: bigint): number {
31375 if(!isWasmInitialized) {
31376 throw new Error("initializeWasm() must be awaited first!");
31378 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_max_accepted_htlcs(this_ptr);
31379 return nativeResponseValue;
31381 // void AcceptChannelV2_set_max_accepted_htlcs(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
31383 export function AcceptChannelV2_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
31384 if(!isWasmInitialized) {
31385 throw new Error("initializeWasm() must be awaited first!");
31387 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_max_accepted_htlcs(this_ptr, val);
31388 // debug statements here
31390 // struct LDKPublicKey AcceptChannelV2_get_funding_pubkey(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31392 export function AcceptChannelV2_get_funding_pubkey(this_ptr: bigint): number {
31393 if(!isWasmInitialized) {
31394 throw new Error("initializeWasm() must be awaited first!");
31396 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_funding_pubkey(this_ptr);
31397 return nativeResponseValue;
31399 // void AcceptChannelV2_set_funding_pubkey(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31401 export function AcceptChannelV2_set_funding_pubkey(this_ptr: bigint, val: number): void {
31402 if(!isWasmInitialized) {
31403 throw new Error("initializeWasm() must be awaited first!");
31405 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_funding_pubkey(this_ptr, val);
31406 // debug statements here
31408 // struct LDKPublicKey AcceptChannelV2_get_revocation_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31410 export function AcceptChannelV2_get_revocation_basepoint(this_ptr: bigint): number {
31411 if(!isWasmInitialized) {
31412 throw new Error("initializeWasm() must be awaited first!");
31414 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_revocation_basepoint(this_ptr);
31415 return nativeResponseValue;
31417 // void AcceptChannelV2_set_revocation_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31419 export function AcceptChannelV2_set_revocation_basepoint(this_ptr: bigint, val: number): void {
31420 if(!isWasmInitialized) {
31421 throw new Error("initializeWasm() must be awaited first!");
31423 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_revocation_basepoint(this_ptr, val);
31424 // debug statements here
31426 // struct LDKPublicKey AcceptChannelV2_get_payment_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31428 export function AcceptChannelV2_get_payment_basepoint(this_ptr: bigint): number {
31429 if(!isWasmInitialized) {
31430 throw new Error("initializeWasm() must be awaited first!");
31432 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_payment_basepoint(this_ptr);
31433 return nativeResponseValue;
31435 // void AcceptChannelV2_set_payment_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31437 export function AcceptChannelV2_set_payment_basepoint(this_ptr: bigint, val: number): void {
31438 if(!isWasmInitialized) {
31439 throw new Error("initializeWasm() must be awaited first!");
31441 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_payment_basepoint(this_ptr, val);
31442 // debug statements here
31444 // struct LDKPublicKey AcceptChannelV2_get_delayed_payment_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31446 export function AcceptChannelV2_get_delayed_payment_basepoint(this_ptr: bigint): number {
31447 if(!isWasmInitialized) {
31448 throw new Error("initializeWasm() must be awaited first!");
31450 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_delayed_payment_basepoint(this_ptr);
31451 return nativeResponseValue;
31453 // void AcceptChannelV2_set_delayed_payment_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31455 export function AcceptChannelV2_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
31456 if(!isWasmInitialized) {
31457 throw new Error("initializeWasm() must be awaited first!");
31459 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_delayed_payment_basepoint(this_ptr, val);
31460 // debug statements here
31462 // struct LDKPublicKey AcceptChannelV2_get_htlc_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31464 export function AcceptChannelV2_get_htlc_basepoint(this_ptr: bigint): number {
31465 if(!isWasmInitialized) {
31466 throw new Error("initializeWasm() must be awaited first!");
31468 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_htlc_basepoint(this_ptr);
31469 return nativeResponseValue;
31471 // void AcceptChannelV2_set_htlc_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31473 export function AcceptChannelV2_set_htlc_basepoint(this_ptr: bigint, val: number): void {
31474 if(!isWasmInitialized) {
31475 throw new Error("initializeWasm() must be awaited first!");
31477 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_htlc_basepoint(this_ptr, val);
31478 // debug statements here
31480 // struct LDKPublicKey AcceptChannelV2_get_first_per_commitment_point(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31482 export function AcceptChannelV2_get_first_per_commitment_point(this_ptr: bigint): number {
31483 if(!isWasmInitialized) {
31484 throw new Error("initializeWasm() must be awaited first!");
31486 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_first_per_commitment_point(this_ptr);
31487 return nativeResponseValue;
31489 // void AcceptChannelV2_set_first_per_commitment_point(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31491 export function AcceptChannelV2_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
31492 if(!isWasmInitialized) {
31493 throw new Error("initializeWasm() must be awaited first!");
31495 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_first_per_commitment_point(this_ptr, val);
31496 // debug statements here
31498 // struct LDKPublicKey AcceptChannelV2_get_second_per_commitment_point(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31500 export function AcceptChannelV2_get_second_per_commitment_point(this_ptr: bigint): number {
31501 if(!isWasmInitialized) {
31502 throw new Error("initializeWasm() must be awaited first!");
31504 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_second_per_commitment_point(this_ptr);
31505 return nativeResponseValue;
31507 // void AcceptChannelV2_set_second_per_commitment_point(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31509 export function AcceptChannelV2_set_second_per_commitment_point(this_ptr: bigint, val: number): void {
31510 if(!isWasmInitialized) {
31511 throw new Error("initializeWasm() must be awaited first!");
31513 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_second_per_commitment_point(this_ptr, val);
31514 // debug statements here
31516 // struct LDKCOption_CVec_u8ZZ AcceptChannelV2_get_shutdown_scriptpubkey(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31518 export function AcceptChannelV2_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
31519 if(!isWasmInitialized) {
31520 throw new Error("initializeWasm() must be awaited first!");
31522 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_shutdown_scriptpubkey(this_ptr);
31523 return nativeResponseValue;
31525 // void AcceptChannelV2_set_shutdown_scriptpubkey(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
31527 export function AcceptChannelV2_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
31528 if(!isWasmInitialized) {
31529 throw new Error("initializeWasm() must be awaited first!");
31531 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_shutdown_scriptpubkey(this_ptr, val);
31532 // debug statements here
31534 // struct LDKChannelTypeFeatures AcceptChannelV2_get_channel_type(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31536 export function AcceptChannelV2_get_channel_type(this_ptr: bigint): bigint {
31537 if(!isWasmInitialized) {
31538 throw new Error("initializeWasm() must be awaited first!");
31540 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_channel_type(this_ptr);
31541 return nativeResponseValue;
31543 // void AcceptChannelV2_set_channel_type(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
31545 export function AcceptChannelV2_set_channel_type(this_ptr: bigint, val: bigint): void {
31546 if(!isWasmInitialized) {
31547 throw new Error("initializeWasm() must be awaited first!");
31549 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_channel_type(this_ptr, val);
31550 // debug statements here
31552 // enum LDKCOption_NoneZ AcceptChannelV2_get_require_confirmed_inputs(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
31554 export function AcceptChannelV2_get_require_confirmed_inputs(this_ptr: bigint): COption_NoneZ {
31555 if(!isWasmInitialized) {
31556 throw new Error("initializeWasm() must be awaited first!");
31558 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_require_confirmed_inputs(this_ptr);
31559 return nativeResponseValue;
31561 // void AcceptChannelV2_set_require_confirmed_inputs(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
31563 export function AcceptChannelV2_set_require_confirmed_inputs(this_ptr: bigint, val: COption_NoneZ): void {
31564 if(!isWasmInitialized) {
31565 throw new Error("initializeWasm() must be awaited first!");
31567 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_require_confirmed_inputs(this_ptr, val);
31568 // debug statements here
31570 // MUST_USE_RES struct LDKAcceptChannelV2 AcceptChannelV2_new(struct LDKThirtyTwoBytes 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 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 LDKPublicKey second_per_commitment_point_arg, struct LDKCOption_CVec_u8ZZ shutdown_scriptpubkey_arg, struct LDKChannelTypeFeatures channel_type_arg, enum LDKCOption_NoneZ require_confirmed_inputs_arg);
31572 export function AcceptChannelV2_new(temporary_channel_id_arg: number, funding_satoshis_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, second_per_commitment_point_arg: number, shutdown_scriptpubkey_arg: bigint, channel_type_arg: bigint, require_confirmed_inputs_arg: COption_NoneZ): bigint {
31573 if(!isWasmInitialized) {
31574 throw new Error("initializeWasm() must be awaited first!");
31576 const nativeResponseValue = wasm.TS_AcceptChannelV2_new(temporary_channel_id_arg, funding_satoshis_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, second_per_commitment_point_arg, shutdown_scriptpubkey_arg, channel_type_arg, require_confirmed_inputs_arg);
31577 return nativeResponseValue;
31579 // uint64_t AcceptChannelV2_clone_ptr(LDKAcceptChannelV2 *NONNULL_PTR arg);
31581 export function AcceptChannelV2_clone_ptr(arg: bigint): bigint {
31582 if(!isWasmInitialized) {
31583 throw new Error("initializeWasm() must be awaited first!");
31585 const nativeResponseValue = wasm.TS_AcceptChannelV2_clone_ptr(arg);
31586 return nativeResponseValue;
31588 // struct LDKAcceptChannelV2 AcceptChannelV2_clone(const struct LDKAcceptChannelV2 *NONNULL_PTR orig);
31590 export function AcceptChannelV2_clone(orig: bigint): bigint {
31591 if(!isWasmInitialized) {
31592 throw new Error("initializeWasm() must be awaited first!");
31594 const nativeResponseValue = wasm.TS_AcceptChannelV2_clone(orig);
31595 return nativeResponseValue;
31597 // bool AcceptChannelV2_eq(const struct LDKAcceptChannelV2 *NONNULL_PTR a, const struct LDKAcceptChannelV2 *NONNULL_PTR b);
31599 export function AcceptChannelV2_eq(a: bigint, b: bigint): boolean {
31600 if(!isWasmInitialized) {
31601 throw new Error("initializeWasm() must be awaited first!");
31603 const nativeResponseValue = wasm.TS_AcceptChannelV2_eq(a, b);
31604 return nativeResponseValue;
31606 // void FundingCreated_free(struct LDKFundingCreated this_obj);
31608 export function FundingCreated_free(this_obj: bigint): void {
31609 if(!isWasmInitialized) {
31610 throw new Error("initializeWasm() must be awaited first!");
31612 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
31613 // debug statements here
31615 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
31617 export function FundingCreated_get_temporary_channel_id(this_ptr: bigint): number {
31618 if(!isWasmInitialized) {
31619 throw new Error("initializeWasm() must be awaited first!");
31621 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
31622 return nativeResponseValue;
31624 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31626 export function FundingCreated_set_temporary_channel_id(this_ptr: bigint, val: number): void {
31627 if(!isWasmInitialized) {
31628 throw new Error("initializeWasm() must be awaited first!");
31630 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
31631 // debug statements here
31633 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
31635 export function FundingCreated_get_funding_txid(this_ptr: bigint): number {
31636 if(!isWasmInitialized) {
31637 throw new Error("initializeWasm() must be awaited first!");
31639 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
31640 return nativeResponseValue;
31642 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31644 export function FundingCreated_set_funding_txid(this_ptr: bigint, val: number): void {
31645 if(!isWasmInitialized) {
31646 throw new Error("initializeWasm() must be awaited first!");
31648 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
31649 // debug statements here
31651 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
31653 export function FundingCreated_get_funding_output_index(this_ptr: bigint): number {
31654 if(!isWasmInitialized) {
31655 throw new Error("initializeWasm() must be awaited first!");
31657 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
31658 return nativeResponseValue;
31660 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
31662 export function FundingCreated_set_funding_output_index(this_ptr: bigint, val: number): void {
31663 if(!isWasmInitialized) {
31664 throw new Error("initializeWasm() must be awaited first!");
31666 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
31667 // debug statements here
31669 // struct LDKECDSASignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
31671 export function FundingCreated_get_signature(this_ptr: bigint): number {
31672 if(!isWasmInitialized) {
31673 throw new Error("initializeWasm() must be awaited first!");
31675 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
31676 return nativeResponseValue;
31678 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
31680 export function FundingCreated_set_signature(this_ptr: bigint, val: number): void {
31681 if(!isWasmInitialized) {
31682 throw new Error("initializeWasm() must be awaited first!");
31684 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
31685 // debug statements here
31687 // MUST_USE_RES struct LDKFundingCreated FundingCreated_new(struct LDKThirtyTwoBytes temporary_channel_id_arg, struct LDKThirtyTwoBytes funding_txid_arg, uint16_t funding_output_index_arg, struct LDKECDSASignature signature_arg);
31689 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): bigint {
31690 if(!isWasmInitialized) {
31691 throw new Error("initializeWasm() must be awaited first!");
31693 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
31694 return nativeResponseValue;
31696 // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
31698 export function FundingCreated_clone_ptr(arg: bigint): bigint {
31699 if(!isWasmInitialized) {
31700 throw new Error("initializeWasm() must be awaited first!");
31702 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
31703 return nativeResponseValue;
31705 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
31707 export function FundingCreated_clone(orig: bigint): bigint {
31708 if(!isWasmInitialized) {
31709 throw new Error("initializeWasm() must be awaited first!");
31711 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
31712 return nativeResponseValue;
31714 // bool FundingCreated_eq(const struct LDKFundingCreated *NONNULL_PTR a, const struct LDKFundingCreated *NONNULL_PTR b);
31716 export function FundingCreated_eq(a: bigint, b: bigint): boolean {
31717 if(!isWasmInitialized) {
31718 throw new Error("initializeWasm() must be awaited first!");
31720 const nativeResponseValue = wasm.TS_FundingCreated_eq(a, b);
31721 return nativeResponseValue;
31723 // void FundingSigned_free(struct LDKFundingSigned this_obj);
31725 export function FundingSigned_free(this_obj: bigint): void {
31726 if(!isWasmInitialized) {
31727 throw new Error("initializeWasm() must be awaited first!");
31729 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
31730 // debug statements here
31732 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
31734 export function FundingSigned_get_channel_id(this_ptr: bigint): number {
31735 if(!isWasmInitialized) {
31736 throw new Error("initializeWasm() must be awaited first!");
31738 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
31739 return nativeResponseValue;
31741 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31743 export function FundingSigned_set_channel_id(this_ptr: bigint, val: number): void {
31744 if(!isWasmInitialized) {
31745 throw new Error("initializeWasm() must be awaited first!");
31747 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
31748 // debug statements here
31750 // struct LDKECDSASignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
31752 export function FundingSigned_get_signature(this_ptr: bigint): number {
31753 if(!isWasmInitialized) {
31754 throw new Error("initializeWasm() must be awaited first!");
31756 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
31757 return nativeResponseValue;
31759 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
31761 export function FundingSigned_set_signature(this_ptr: bigint, val: number): void {
31762 if(!isWasmInitialized) {
31763 throw new Error("initializeWasm() must be awaited first!");
31765 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
31766 // debug statements here
31768 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKECDSASignature signature_arg);
31770 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): bigint {
31771 if(!isWasmInitialized) {
31772 throw new Error("initializeWasm() must be awaited first!");
31774 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
31775 return nativeResponseValue;
31777 // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
31779 export function FundingSigned_clone_ptr(arg: bigint): bigint {
31780 if(!isWasmInitialized) {
31781 throw new Error("initializeWasm() must be awaited first!");
31783 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
31784 return nativeResponseValue;
31786 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
31788 export function FundingSigned_clone(orig: bigint): bigint {
31789 if(!isWasmInitialized) {
31790 throw new Error("initializeWasm() must be awaited first!");
31792 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
31793 return nativeResponseValue;
31795 // bool FundingSigned_eq(const struct LDKFundingSigned *NONNULL_PTR a, const struct LDKFundingSigned *NONNULL_PTR b);
31797 export function FundingSigned_eq(a: bigint, b: bigint): boolean {
31798 if(!isWasmInitialized) {
31799 throw new Error("initializeWasm() must be awaited first!");
31801 const nativeResponseValue = wasm.TS_FundingSigned_eq(a, b);
31802 return nativeResponseValue;
31804 // void ChannelReady_free(struct LDKChannelReady this_obj);
31806 export function ChannelReady_free(this_obj: bigint): void {
31807 if(!isWasmInitialized) {
31808 throw new Error("initializeWasm() must be awaited first!");
31810 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
31811 // debug statements here
31813 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
31815 export function ChannelReady_get_channel_id(this_ptr: bigint): number {
31816 if(!isWasmInitialized) {
31817 throw new Error("initializeWasm() must be awaited first!");
31819 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
31820 return nativeResponseValue;
31822 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31824 export function ChannelReady_set_channel_id(this_ptr: bigint, val: number): void {
31825 if(!isWasmInitialized) {
31826 throw new Error("initializeWasm() must be awaited first!");
31828 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
31829 // debug statements here
31831 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
31833 export function ChannelReady_get_next_per_commitment_point(this_ptr: bigint): number {
31834 if(!isWasmInitialized) {
31835 throw new Error("initializeWasm() must be awaited first!");
31837 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
31838 return nativeResponseValue;
31840 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31842 export function ChannelReady_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
31843 if(!isWasmInitialized) {
31844 throw new Error("initializeWasm() must be awaited first!");
31846 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
31847 // debug statements here
31849 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
31851 export function ChannelReady_get_short_channel_id_alias(this_ptr: bigint): bigint {
31852 if(!isWasmInitialized) {
31853 throw new Error("initializeWasm() must be awaited first!");
31855 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
31856 return nativeResponseValue;
31858 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
31860 export function ChannelReady_set_short_channel_id_alias(this_ptr: bigint, val: bigint): void {
31861 if(!isWasmInitialized) {
31862 throw new Error("initializeWasm() must be awaited first!");
31864 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
31865 // debug statements here
31867 // MUST_USE_RES struct LDKChannelReady ChannelReady_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg, struct LDKCOption_u64Z short_channel_id_alias_arg);
31869 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: bigint): bigint {
31870 if(!isWasmInitialized) {
31871 throw new Error("initializeWasm() must be awaited first!");
31873 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
31874 return nativeResponseValue;
31876 // uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
31878 export function ChannelReady_clone_ptr(arg: bigint): bigint {
31879 if(!isWasmInitialized) {
31880 throw new Error("initializeWasm() must be awaited first!");
31882 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
31883 return nativeResponseValue;
31885 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
31887 export function ChannelReady_clone(orig: bigint): bigint {
31888 if(!isWasmInitialized) {
31889 throw new Error("initializeWasm() must be awaited first!");
31891 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
31892 return nativeResponseValue;
31894 // bool ChannelReady_eq(const struct LDKChannelReady *NONNULL_PTR a, const struct LDKChannelReady *NONNULL_PTR b);
31896 export function ChannelReady_eq(a: bigint, b: bigint): boolean {
31897 if(!isWasmInitialized) {
31898 throw new Error("initializeWasm() must be awaited first!");
31900 const nativeResponseValue = wasm.TS_ChannelReady_eq(a, b);
31901 return nativeResponseValue;
31903 // void TxAddInput_free(struct LDKTxAddInput this_obj);
31905 export function TxAddInput_free(this_obj: bigint): void {
31906 if(!isWasmInitialized) {
31907 throw new Error("initializeWasm() must be awaited first!");
31909 const nativeResponseValue = wasm.TS_TxAddInput_free(this_obj);
31910 // debug statements here
31912 // const uint8_t (*TxAddInput_get_channel_id(const struct LDKTxAddInput *NONNULL_PTR this_ptr))[32];
31914 export function TxAddInput_get_channel_id(this_ptr: bigint): number {
31915 if(!isWasmInitialized) {
31916 throw new Error("initializeWasm() must be awaited first!");
31918 const nativeResponseValue = wasm.TS_TxAddInput_get_channel_id(this_ptr);
31919 return nativeResponseValue;
31921 // void TxAddInput_set_channel_id(struct LDKTxAddInput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
31923 export function TxAddInput_set_channel_id(this_ptr: bigint, val: number): void {
31924 if(!isWasmInitialized) {
31925 throw new Error("initializeWasm() must be awaited first!");
31927 const nativeResponseValue = wasm.TS_TxAddInput_set_channel_id(this_ptr, val);
31928 // debug statements here
31930 // uint64_t TxAddInput_get_serial_id(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
31932 export function TxAddInput_get_serial_id(this_ptr: bigint): bigint {
31933 if(!isWasmInitialized) {
31934 throw new Error("initializeWasm() must be awaited first!");
31936 const nativeResponseValue = wasm.TS_TxAddInput_get_serial_id(this_ptr);
31937 return nativeResponseValue;
31939 // void TxAddInput_set_serial_id(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint64_t val);
31941 export function TxAddInput_set_serial_id(this_ptr: bigint, val: bigint): void {
31942 if(!isWasmInitialized) {
31943 throw new Error("initializeWasm() must be awaited first!");
31945 const nativeResponseValue = wasm.TS_TxAddInput_set_serial_id(this_ptr, val);
31946 // debug statements here
31948 // struct LDKTransactionU16LenLimited TxAddInput_get_prevtx(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
31950 export function TxAddInput_get_prevtx(this_ptr: bigint): bigint {
31951 if(!isWasmInitialized) {
31952 throw new Error("initializeWasm() must be awaited first!");
31954 const nativeResponseValue = wasm.TS_TxAddInput_get_prevtx(this_ptr);
31955 return nativeResponseValue;
31957 // void TxAddInput_set_prevtx(struct LDKTxAddInput *NONNULL_PTR this_ptr, struct LDKTransactionU16LenLimited val);
31959 export function TxAddInput_set_prevtx(this_ptr: bigint, val: bigint): void {
31960 if(!isWasmInitialized) {
31961 throw new Error("initializeWasm() must be awaited first!");
31963 const nativeResponseValue = wasm.TS_TxAddInput_set_prevtx(this_ptr, val);
31964 // debug statements here
31966 // uint32_t TxAddInput_get_prevtx_out(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
31968 export function TxAddInput_get_prevtx_out(this_ptr: bigint): number {
31969 if(!isWasmInitialized) {
31970 throw new Error("initializeWasm() must be awaited first!");
31972 const nativeResponseValue = wasm.TS_TxAddInput_get_prevtx_out(this_ptr);
31973 return nativeResponseValue;
31975 // void TxAddInput_set_prevtx_out(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint32_t val);
31977 export function TxAddInput_set_prevtx_out(this_ptr: bigint, val: number): void {
31978 if(!isWasmInitialized) {
31979 throw new Error("initializeWasm() must be awaited first!");
31981 const nativeResponseValue = wasm.TS_TxAddInput_set_prevtx_out(this_ptr, val);
31982 // debug statements here
31984 // uint32_t TxAddInput_get_sequence(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
31986 export function TxAddInput_get_sequence(this_ptr: bigint): number {
31987 if(!isWasmInitialized) {
31988 throw new Error("initializeWasm() must be awaited first!");
31990 const nativeResponseValue = wasm.TS_TxAddInput_get_sequence(this_ptr);
31991 return nativeResponseValue;
31993 // void TxAddInput_set_sequence(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint32_t val);
31995 export function TxAddInput_set_sequence(this_ptr: bigint, val: number): void {
31996 if(!isWasmInitialized) {
31997 throw new Error("initializeWasm() must be awaited first!");
31999 const nativeResponseValue = wasm.TS_TxAddInput_set_sequence(this_ptr, val);
32000 // debug statements here
32002 // MUST_USE_RES struct LDKTxAddInput TxAddInput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg, struct LDKTransactionU16LenLimited prevtx_arg, uint32_t prevtx_out_arg, uint32_t sequence_arg);
32004 export function TxAddInput_new(channel_id_arg: number, serial_id_arg: bigint, prevtx_arg: bigint, prevtx_out_arg: number, sequence_arg: number): bigint {
32005 if(!isWasmInitialized) {
32006 throw new Error("initializeWasm() must be awaited first!");
32008 const nativeResponseValue = wasm.TS_TxAddInput_new(channel_id_arg, serial_id_arg, prevtx_arg, prevtx_out_arg, sequence_arg);
32009 return nativeResponseValue;
32011 // uint64_t TxAddInput_clone_ptr(LDKTxAddInput *NONNULL_PTR arg);
32013 export function TxAddInput_clone_ptr(arg: bigint): bigint {
32014 if(!isWasmInitialized) {
32015 throw new Error("initializeWasm() must be awaited first!");
32017 const nativeResponseValue = wasm.TS_TxAddInput_clone_ptr(arg);
32018 return nativeResponseValue;
32020 // struct LDKTxAddInput TxAddInput_clone(const struct LDKTxAddInput *NONNULL_PTR orig);
32022 export function TxAddInput_clone(orig: bigint): bigint {
32023 if(!isWasmInitialized) {
32024 throw new Error("initializeWasm() must be awaited first!");
32026 const nativeResponseValue = wasm.TS_TxAddInput_clone(orig);
32027 return nativeResponseValue;
32029 // bool TxAddInput_eq(const struct LDKTxAddInput *NONNULL_PTR a, const struct LDKTxAddInput *NONNULL_PTR b);
32031 export function TxAddInput_eq(a: bigint, b: bigint): boolean {
32032 if(!isWasmInitialized) {
32033 throw new Error("initializeWasm() must be awaited first!");
32035 const nativeResponseValue = wasm.TS_TxAddInput_eq(a, b);
32036 return nativeResponseValue;
32038 // void TxAddOutput_free(struct LDKTxAddOutput this_obj);
32040 export function TxAddOutput_free(this_obj: bigint): void {
32041 if(!isWasmInitialized) {
32042 throw new Error("initializeWasm() must be awaited first!");
32044 const nativeResponseValue = wasm.TS_TxAddOutput_free(this_obj);
32045 // debug statements here
32047 // const uint8_t (*TxAddOutput_get_channel_id(const struct LDKTxAddOutput *NONNULL_PTR this_ptr))[32];
32049 export function TxAddOutput_get_channel_id(this_ptr: bigint): number {
32050 if(!isWasmInitialized) {
32051 throw new Error("initializeWasm() must be awaited first!");
32053 const nativeResponseValue = wasm.TS_TxAddOutput_get_channel_id(this_ptr);
32054 return nativeResponseValue;
32056 // void TxAddOutput_set_channel_id(struct LDKTxAddOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32058 export function TxAddOutput_set_channel_id(this_ptr: bigint, val: number): void {
32059 if(!isWasmInitialized) {
32060 throw new Error("initializeWasm() must be awaited first!");
32062 const nativeResponseValue = wasm.TS_TxAddOutput_set_channel_id(this_ptr, val);
32063 // debug statements here
32065 // uint64_t TxAddOutput_get_serial_id(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
32067 export function TxAddOutput_get_serial_id(this_ptr: bigint): bigint {
32068 if(!isWasmInitialized) {
32069 throw new Error("initializeWasm() must be awaited first!");
32071 const nativeResponseValue = wasm.TS_TxAddOutput_get_serial_id(this_ptr);
32072 return nativeResponseValue;
32074 // void TxAddOutput_set_serial_id(struct LDKTxAddOutput *NONNULL_PTR this_ptr, uint64_t val);
32076 export function TxAddOutput_set_serial_id(this_ptr: bigint, val: bigint): void {
32077 if(!isWasmInitialized) {
32078 throw new Error("initializeWasm() must be awaited first!");
32080 const nativeResponseValue = wasm.TS_TxAddOutput_set_serial_id(this_ptr, val);
32081 // debug statements here
32083 // uint64_t TxAddOutput_get_sats(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
32085 export function TxAddOutput_get_sats(this_ptr: bigint): bigint {
32086 if(!isWasmInitialized) {
32087 throw new Error("initializeWasm() must be awaited first!");
32089 const nativeResponseValue = wasm.TS_TxAddOutput_get_sats(this_ptr);
32090 return nativeResponseValue;
32092 // void TxAddOutput_set_sats(struct LDKTxAddOutput *NONNULL_PTR this_ptr, uint64_t val);
32094 export function TxAddOutput_set_sats(this_ptr: bigint, val: bigint): void {
32095 if(!isWasmInitialized) {
32096 throw new Error("initializeWasm() must be awaited first!");
32098 const nativeResponseValue = wasm.TS_TxAddOutput_set_sats(this_ptr, val);
32099 // debug statements here
32101 // struct LDKu8slice TxAddOutput_get_script(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
32103 export function TxAddOutput_get_script(this_ptr: bigint): number {
32104 if(!isWasmInitialized) {
32105 throw new Error("initializeWasm() must be awaited first!");
32107 const nativeResponseValue = wasm.TS_TxAddOutput_get_script(this_ptr);
32108 return nativeResponseValue;
32110 // void TxAddOutput_set_script(struct LDKTxAddOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
32112 export function TxAddOutput_set_script(this_ptr: bigint, val: number): void {
32113 if(!isWasmInitialized) {
32114 throw new Error("initializeWasm() must be awaited first!");
32116 const nativeResponseValue = wasm.TS_TxAddOutput_set_script(this_ptr, val);
32117 // debug statements here
32119 // MUST_USE_RES struct LDKTxAddOutput TxAddOutput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg, uint64_t sats_arg, struct LDKCVec_u8Z script_arg);
32121 export function TxAddOutput_new(channel_id_arg: number, serial_id_arg: bigint, sats_arg: bigint, script_arg: number): bigint {
32122 if(!isWasmInitialized) {
32123 throw new Error("initializeWasm() must be awaited first!");
32125 const nativeResponseValue = wasm.TS_TxAddOutput_new(channel_id_arg, serial_id_arg, sats_arg, script_arg);
32126 return nativeResponseValue;
32128 // uint64_t TxAddOutput_clone_ptr(LDKTxAddOutput *NONNULL_PTR arg);
32130 export function TxAddOutput_clone_ptr(arg: bigint): bigint {
32131 if(!isWasmInitialized) {
32132 throw new Error("initializeWasm() must be awaited first!");
32134 const nativeResponseValue = wasm.TS_TxAddOutput_clone_ptr(arg);
32135 return nativeResponseValue;
32137 // struct LDKTxAddOutput TxAddOutput_clone(const struct LDKTxAddOutput *NONNULL_PTR orig);
32139 export function TxAddOutput_clone(orig: bigint): bigint {
32140 if(!isWasmInitialized) {
32141 throw new Error("initializeWasm() must be awaited first!");
32143 const nativeResponseValue = wasm.TS_TxAddOutput_clone(orig);
32144 return nativeResponseValue;
32146 // bool TxAddOutput_eq(const struct LDKTxAddOutput *NONNULL_PTR a, const struct LDKTxAddOutput *NONNULL_PTR b);
32148 export function TxAddOutput_eq(a: bigint, b: bigint): boolean {
32149 if(!isWasmInitialized) {
32150 throw new Error("initializeWasm() must be awaited first!");
32152 const nativeResponseValue = wasm.TS_TxAddOutput_eq(a, b);
32153 return nativeResponseValue;
32155 // void TxRemoveInput_free(struct LDKTxRemoveInput this_obj);
32157 export function TxRemoveInput_free(this_obj: bigint): void {
32158 if(!isWasmInitialized) {
32159 throw new Error("initializeWasm() must be awaited first!");
32161 const nativeResponseValue = wasm.TS_TxRemoveInput_free(this_obj);
32162 // debug statements here
32164 // const uint8_t (*TxRemoveInput_get_channel_id(const struct LDKTxRemoveInput *NONNULL_PTR this_ptr))[32];
32166 export function TxRemoveInput_get_channel_id(this_ptr: bigint): number {
32167 if(!isWasmInitialized) {
32168 throw new Error("initializeWasm() must be awaited first!");
32170 const nativeResponseValue = wasm.TS_TxRemoveInput_get_channel_id(this_ptr);
32171 return nativeResponseValue;
32173 // void TxRemoveInput_set_channel_id(struct LDKTxRemoveInput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32175 export function TxRemoveInput_set_channel_id(this_ptr: bigint, val: number): void {
32176 if(!isWasmInitialized) {
32177 throw new Error("initializeWasm() must be awaited first!");
32179 const nativeResponseValue = wasm.TS_TxRemoveInput_set_channel_id(this_ptr, val);
32180 // debug statements here
32182 // uint64_t TxRemoveInput_get_serial_id(const struct LDKTxRemoveInput *NONNULL_PTR this_ptr);
32184 export function TxRemoveInput_get_serial_id(this_ptr: bigint): bigint {
32185 if(!isWasmInitialized) {
32186 throw new Error("initializeWasm() must be awaited first!");
32188 const nativeResponseValue = wasm.TS_TxRemoveInput_get_serial_id(this_ptr);
32189 return nativeResponseValue;
32191 // void TxRemoveInput_set_serial_id(struct LDKTxRemoveInput *NONNULL_PTR this_ptr, uint64_t val);
32193 export function TxRemoveInput_set_serial_id(this_ptr: bigint, val: bigint): void {
32194 if(!isWasmInitialized) {
32195 throw new Error("initializeWasm() must be awaited first!");
32197 const nativeResponseValue = wasm.TS_TxRemoveInput_set_serial_id(this_ptr, val);
32198 // debug statements here
32200 // MUST_USE_RES struct LDKTxRemoveInput TxRemoveInput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg);
32202 export function TxRemoveInput_new(channel_id_arg: number, serial_id_arg: bigint): bigint {
32203 if(!isWasmInitialized) {
32204 throw new Error("initializeWasm() must be awaited first!");
32206 const nativeResponseValue = wasm.TS_TxRemoveInput_new(channel_id_arg, serial_id_arg);
32207 return nativeResponseValue;
32209 // uint64_t TxRemoveInput_clone_ptr(LDKTxRemoveInput *NONNULL_PTR arg);
32211 export function TxRemoveInput_clone_ptr(arg: bigint): bigint {
32212 if(!isWasmInitialized) {
32213 throw new Error("initializeWasm() must be awaited first!");
32215 const nativeResponseValue = wasm.TS_TxRemoveInput_clone_ptr(arg);
32216 return nativeResponseValue;
32218 // struct LDKTxRemoveInput TxRemoveInput_clone(const struct LDKTxRemoveInput *NONNULL_PTR orig);
32220 export function TxRemoveInput_clone(orig: bigint): bigint {
32221 if(!isWasmInitialized) {
32222 throw new Error("initializeWasm() must be awaited first!");
32224 const nativeResponseValue = wasm.TS_TxRemoveInput_clone(orig);
32225 return nativeResponseValue;
32227 // bool TxRemoveInput_eq(const struct LDKTxRemoveInput *NONNULL_PTR a, const struct LDKTxRemoveInput *NONNULL_PTR b);
32229 export function TxRemoveInput_eq(a: bigint, b: bigint): boolean {
32230 if(!isWasmInitialized) {
32231 throw new Error("initializeWasm() must be awaited first!");
32233 const nativeResponseValue = wasm.TS_TxRemoveInput_eq(a, b);
32234 return nativeResponseValue;
32236 // void TxRemoveOutput_free(struct LDKTxRemoveOutput this_obj);
32238 export function TxRemoveOutput_free(this_obj: bigint): void {
32239 if(!isWasmInitialized) {
32240 throw new Error("initializeWasm() must be awaited first!");
32242 const nativeResponseValue = wasm.TS_TxRemoveOutput_free(this_obj);
32243 // debug statements here
32245 // const uint8_t (*TxRemoveOutput_get_channel_id(const struct LDKTxRemoveOutput *NONNULL_PTR this_ptr))[32];
32247 export function TxRemoveOutput_get_channel_id(this_ptr: bigint): number {
32248 if(!isWasmInitialized) {
32249 throw new Error("initializeWasm() must be awaited first!");
32251 const nativeResponseValue = wasm.TS_TxRemoveOutput_get_channel_id(this_ptr);
32252 return nativeResponseValue;
32254 // void TxRemoveOutput_set_channel_id(struct LDKTxRemoveOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32256 export function TxRemoveOutput_set_channel_id(this_ptr: bigint, val: number): void {
32257 if(!isWasmInitialized) {
32258 throw new Error("initializeWasm() must be awaited first!");
32260 const nativeResponseValue = wasm.TS_TxRemoveOutput_set_channel_id(this_ptr, val);
32261 // debug statements here
32263 // uint64_t TxRemoveOutput_get_serial_id(const struct LDKTxRemoveOutput *NONNULL_PTR this_ptr);
32265 export function TxRemoveOutput_get_serial_id(this_ptr: bigint): bigint {
32266 if(!isWasmInitialized) {
32267 throw new Error("initializeWasm() must be awaited first!");
32269 const nativeResponseValue = wasm.TS_TxRemoveOutput_get_serial_id(this_ptr);
32270 return nativeResponseValue;
32272 // void TxRemoveOutput_set_serial_id(struct LDKTxRemoveOutput *NONNULL_PTR this_ptr, uint64_t val);
32274 export function TxRemoveOutput_set_serial_id(this_ptr: bigint, val: bigint): void {
32275 if(!isWasmInitialized) {
32276 throw new Error("initializeWasm() must be awaited first!");
32278 const nativeResponseValue = wasm.TS_TxRemoveOutput_set_serial_id(this_ptr, val);
32279 // debug statements here
32281 // MUST_USE_RES struct LDKTxRemoveOutput TxRemoveOutput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg);
32283 export function TxRemoveOutput_new(channel_id_arg: number, serial_id_arg: bigint): bigint {
32284 if(!isWasmInitialized) {
32285 throw new Error("initializeWasm() must be awaited first!");
32287 const nativeResponseValue = wasm.TS_TxRemoveOutput_new(channel_id_arg, serial_id_arg);
32288 return nativeResponseValue;
32290 // uint64_t TxRemoveOutput_clone_ptr(LDKTxRemoveOutput *NONNULL_PTR arg);
32292 export function TxRemoveOutput_clone_ptr(arg: bigint): bigint {
32293 if(!isWasmInitialized) {
32294 throw new Error("initializeWasm() must be awaited first!");
32296 const nativeResponseValue = wasm.TS_TxRemoveOutput_clone_ptr(arg);
32297 return nativeResponseValue;
32299 // struct LDKTxRemoveOutput TxRemoveOutput_clone(const struct LDKTxRemoveOutput *NONNULL_PTR orig);
32301 export function TxRemoveOutput_clone(orig: bigint): bigint {
32302 if(!isWasmInitialized) {
32303 throw new Error("initializeWasm() must be awaited first!");
32305 const nativeResponseValue = wasm.TS_TxRemoveOutput_clone(orig);
32306 return nativeResponseValue;
32308 // bool TxRemoveOutput_eq(const struct LDKTxRemoveOutput *NONNULL_PTR a, const struct LDKTxRemoveOutput *NONNULL_PTR b);
32310 export function TxRemoveOutput_eq(a: bigint, b: bigint): boolean {
32311 if(!isWasmInitialized) {
32312 throw new Error("initializeWasm() must be awaited first!");
32314 const nativeResponseValue = wasm.TS_TxRemoveOutput_eq(a, b);
32315 return nativeResponseValue;
32317 // void TxComplete_free(struct LDKTxComplete this_obj);
32319 export function TxComplete_free(this_obj: bigint): void {
32320 if(!isWasmInitialized) {
32321 throw new Error("initializeWasm() must be awaited first!");
32323 const nativeResponseValue = wasm.TS_TxComplete_free(this_obj);
32324 // debug statements here
32326 // const uint8_t (*TxComplete_get_channel_id(const struct LDKTxComplete *NONNULL_PTR this_ptr))[32];
32328 export function TxComplete_get_channel_id(this_ptr: bigint): number {
32329 if(!isWasmInitialized) {
32330 throw new Error("initializeWasm() must be awaited first!");
32332 const nativeResponseValue = wasm.TS_TxComplete_get_channel_id(this_ptr);
32333 return nativeResponseValue;
32335 // void TxComplete_set_channel_id(struct LDKTxComplete *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32337 export function TxComplete_set_channel_id(this_ptr: bigint, val: number): void {
32338 if(!isWasmInitialized) {
32339 throw new Error("initializeWasm() must be awaited first!");
32341 const nativeResponseValue = wasm.TS_TxComplete_set_channel_id(this_ptr, val);
32342 // debug statements here
32344 // MUST_USE_RES struct LDKTxComplete TxComplete_new(struct LDKThirtyTwoBytes channel_id_arg);
32346 export function TxComplete_new(channel_id_arg: number): bigint {
32347 if(!isWasmInitialized) {
32348 throw new Error("initializeWasm() must be awaited first!");
32350 const nativeResponseValue = wasm.TS_TxComplete_new(channel_id_arg);
32351 return nativeResponseValue;
32353 // uint64_t TxComplete_clone_ptr(LDKTxComplete *NONNULL_PTR arg);
32355 export function TxComplete_clone_ptr(arg: bigint): bigint {
32356 if(!isWasmInitialized) {
32357 throw new Error("initializeWasm() must be awaited first!");
32359 const nativeResponseValue = wasm.TS_TxComplete_clone_ptr(arg);
32360 return nativeResponseValue;
32362 // struct LDKTxComplete TxComplete_clone(const struct LDKTxComplete *NONNULL_PTR orig);
32364 export function TxComplete_clone(orig: bigint): bigint {
32365 if(!isWasmInitialized) {
32366 throw new Error("initializeWasm() must be awaited first!");
32368 const nativeResponseValue = wasm.TS_TxComplete_clone(orig);
32369 return nativeResponseValue;
32371 // bool TxComplete_eq(const struct LDKTxComplete *NONNULL_PTR a, const struct LDKTxComplete *NONNULL_PTR b);
32373 export function TxComplete_eq(a: bigint, b: bigint): boolean {
32374 if(!isWasmInitialized) {
32375 throw new Error("initializeWasm() must be awaited first!");
32377 const nativeResponseValue = wasm.TS_TxComplete_eq(a, b);
32378 return nativeResponseValue;
32380 // void TxSignatures_free(struct LDKTxSignatures this_obj);
32382 export function TxSignatures_free(this_obj: bigint): void {
32383 if(!isWasmInitialized) {
32384 throw new Error("initializeWasm() must be awaited first!");
32386 const nativeResponseValue = wasm.TS_TxSignatures_free(this_obj);
32387 // debug statements here
32389 // const uint8_t (*TxSignatures_get_channel_id(const struct LDKTxSignatures *NONNULL_PTR this_ptr))[32];
32391 export function TxSignatures_get_channel_id(this_ptr: bigint): number {
32392 if(!isWasmInitialized) {
32393 throw new Error("initializeWasm() must be awaited first!");
32395 const nativeResponseValue = wasm.TS_TxSignatures_get_channel_id(this_ptr);
32396 return nativeResponseValue;
32398 // void TxSignatures_set_channel_id(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32400 export function TxSignatures_set_channel_id(this_ptr: bigint, val: number): void {
32401 if(!isWasmInitialized) {
32402 throw new Error("initializeWasm() must be awaited first!");
32404 const nativeResponseValue = wasm.TS_TxSignatures_set_channel_id(this_ptr, val);
32405 // debug statements here
32407 // const uint8_t (*TxSignatures_get_tx_hash(const struct LDKTxSignatures *NONNULL_PTR this_ptr))[32];
32409 export function TxSignatures_get_tx_hash(this_ptr: bigint): number {
32410 if(!isWasmInitialized) {
32411 throw new Error("initializeWasm() must be awaited first!");
32413 const nativeResponseValue = wasm.TS_TxSignatures_get_tx_hash(this_ptr);
32414 return nativeResponseValue;
32416 // void TxSignatures_set_tx_hash(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32418 export function TxSignatures_set_tx_hash(this_ptr: bigint, val: number): void {
32419 if(!isWasmInitialized) {
32420 throw new Error("initializeWasm() must be awaited first!");
32422 const nativeResponseValue = wasm.TS_TxSignatures_set_tx_hash(this_ptr, val);
32423 // debug statements here
32425 // struct LDKCVec_WitnessZ TxSignatures_get_witnesses(const struct LDKTxSignatures *NONNULL_PTR this_ptr);
32427 export function TxSignatures_get_witnesses(this_ptr: bigint): number {
32428 if(!isWasmInitialized) {
32429 throw new Error("initializeWasm() must be awaited first!");
32431 const nativeResponseValue = wasm.TS_TxSignatures_get_witnesses(this_ptr);
32432 return nativeResponseValue;
32434 // void TxSignatures_set_witnesses(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKCVec_WitnessZ val);
32436 export function TxSignatures_set_witnesses(this_ptr: bigint, val: number): void {
32437 if(!isWasmInitialized) {
32438 throw new Error("initializeWasm() must be awaited first!");
32440 const nativeResponseValue = wasm.TS_TxSignatures_set_witnesses(this_ptr, val);
32441 // debug statements here
32443 // MUST_USE_RES struct LDKTxSignatures TxSignatures_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKThirtyTwoBytes tx_hash_arg, struct LDKCVec_WitnessZ witnesses_arg);
32445 export function TxSignatures_new(channel_id_arg: number, tx_hash_arg: number, witnesses_arg: number): bigint {
32446 if(!isWasmInitialized) {
32447 throw new Error("initializeWasm() must be awaited first!");
32449 const nativeResponseValue = wasm.TS_TxSignatures_new(channel_id_arg, tx_hash_arg, witnesses_arg);
32450 return nativeResponseValue;
32452 // uint64_t TxSignatures_clone_ptr(LDKTxSignatures *NONNULL_PTR arg);
32454 export function TxSignatures_clone_ptr(arg: bigint): bigint {
32455 if(!isWasmInitialized) {
32456 throw new Error("initializeWasm() must be awaited first!");
32458 const nativeResponseValue = wasm.TS_TxSignatures_clone_ptr(arg);
32459 return nativeResponseValue;
32461 // struct LDKTxSignatures TxSignatures_clone(const struct LDKTxSignatures *NONNULL_PTR orig);
32463 export function TxSignatures_clone(orig: bigint): bigint {
32464 if(!isWasmInitialized) {
32465 throw new Error("initializeWasm() must be awaited first!");
32467 const nativeResponseValue = wasm.TS_TxSignatures_clone(orig);
32468 return nativeResponseValue;
32470 // bool TxSignatures_eq(const struct LDKTxSignatures *NONNULL_PTR a, const struct LDKTxSignatures *NONNULL_PTR b);
32472 export function TxSignatures_eq(a: bigint, b: bigint): boolean {
32473 if(!isWasmInitialized) {
32474 throw new Error("initializeWasm() must be awaited first!");
32476 const nativeResponseValue = wasm.TS_TxSignatures_eq(a, b);
32477 return nativeResponseValue;
32479 // void TxInitRbf_free(struct LDKTxInitRbf this_obj);
32481 export function TxInitRbf_free(this_obj: bigint): void {
32482 if(!isWasmInitialized) {
32483 throw new Error("initializeWasm() must be awaited first!");
32485 const nativeResponseValue = wasm.TS_TxInitRbf_free(this_obj);
32486 // debug statements here
32488 // const uint8_t (*TxInitRbf_get_channel_id(const struct LDKTxInitRbf *NONNULL_PTR this_ptr))[32];
32490 export function TxInitRbf_get_channel_id(this_ptr: bigint): number {
32491 if(!isWasmInitialized) {
32492 throw new Error("initializeWasm() must be awaited first!");
32494 const nativeResponseValue = wasm.TS_TxInitRbf_get_channel_id(this_ptr);
32495 return nativeResponseValue;
32497 // void TxInitRbf_set_channel_id(struct LDKTxInitRbf *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32499 export function TxInitRbf_set_channel_id(this_ptr: bigint, val: number): void {
32500 if(!isWasmInitialized) {
32501 throw new Error("initializeWasm() must be awaited first!");
32503 const nativeResponseValue = wasm.TS_TxInitRbf_set_channel_id(this_ptr, val);
32504 // debug statements here
32506 // uint32_t TxInitRbf_get_locktime(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
32508 export function TxInitRbf_get_locktime(this_ptr: bigint): number {
32509 if(!isWasmInitialized) {
32510 throw new Error("initializeWasm() must be awaited first!");
32512 const nativeResponseValue = wasm.TS_TxInitRbf_get_locktime(this_ptr);
32513 return nativeResponseValue;
32515 // void TxInitRbf_set_locktime(struct LDKTxInitRbf *NONNULL_PTR this_ptr, uint32_t val);
32517 export function TxInitRbf_set_locktime(this_ptr: bigint, val: number): void {
32518 if(!isWasmInitialized) {
32519 throw new Error("initializeWasm() must be awaited first!");
32521 const nativeResponseValue = wasm.TS_TxInitRbf_set_locktime(this_ptr, val);
32522 // debug statements here
32524 // uint32_t TxInitRbf_get_feerate_sat_per_1000_weight(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
32526 export function TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr: bigint): number {
32527 if(!isWasmInitialized) {
32528 throw new Error("initializeWasm() must be awaited first!");
32530 const nativeResponseValue = wasm.TS_TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr);
32531 return nativeResponseValue;
32533 // void TxInitRbf_set_feerate_sat_per_1000_weight(struct LDKTxInitRbf *NONNULL_PTR this_ptr, uint32_t val);
32535 export function TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
32536 if(!isWasmInitialized) {
32537 throw new Error("initializeWasm() must be awaited first!");
32539 const nativeResponseValue = wasm.TS_TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr, val);
32540 // debug statements here
32542 // struct LDKCOption_i64Z TxInitRbf_get_funding_output_contribution(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
32544 export function TxInitRbf_get_funding_output_contribution(this_ptr: bigint): bigint {
32545 if(!isWasmInitialized) {
32546 throw new Error("initializeWasm() must be awaited first!");
32548 const nativeResponseValue = wasm.TS_TxInitRbf_get_funding_output_contribution(this_ptr);
32549 return nativeResponseValue;
32551 // void TxInitRbf_set_funding_output_contribution(struct LDKTxInitRbf *NONNULL_PTR this_ptr, struct LDKCOption_i64Z val);
32553 export function TxInitRbf_set_funding_output_contribution(this_ptr: bigint, val: bigint): void {
32554 if(!isWasmInitialized) {
32555 throw new Error("initializeWasm() must be awaited first!");
32557 const nativeResponseValue = wasm.TS_TxInitRbf_set_funding_output_contribution(this_ptr, val);
32558 // debug statements here
32560 // MUST_USE_RES struct LDKTxInitRbf TxInitRbf_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t locktime_arg, uint32_t feerate_sat_per_1000_weight_arg, struct LDKCOption_i64Z funding_output_contribution_arg);
32562 export function TxInitRbf_new(channel_id_arg: number, locktime_arg: number, feerate_sat_per_1000_weight_arg: number, funding_output_contribution_arg: bigint): bigint {
32563 if(!isWasmInitialized) {
32564 throw new Error("initializeWasm() must be awaited first!");
32566 const nativeResponseValue = wasm.TS_TxInitRbf_new(channel_id_arg, locktime_arg, feerate_sat_per_1000_weight_arg, funding_output_contribution_arg);
32567 return nativeResponseValue;
32569 // uint64_t TxInitRbf_clone_ptr(LDKTxInitRbf *NONNULL_PTR arg);
32571 export function TxInitRbf_clone_ptr(arg: bigint): bigint {
32572 if(!isWasmInitialized) {
32573 throw new Error("initializeWasm() must be awaited first!");
32575 const nativeResponseValue = wasm.TS_TxInitRbf_clone_ptr(arg);
32576 return nativeResponseValue;
32578 // struct LDKTxInitRbf TxInitRbf_clone(const struct LDKTxInitRbf *NONNULL_PTR orig);
32580 export function TxInitRbf_clone(orig: bigint): bigint {
32581 if(!isWasmInitialized) {
32582 throw new Error("initializeWasm() must be awaited first!");
32584 const nativeResponseValue = wasm.TS_TxInitRbf_clone(orig);
32585 return nativeResponseValue;
32587 // bool TxInitRbf_eq(const struct LDKTxInitRbf *NONNULL_PTR a, const struct LDKTxInitRbf *NONNULL_PTR b);
32589 export function TxInitRbf_eq(a: bigint, b: bigint): boolean {
32590 if(!isWasmInitialized) {
32591 throw new Error("initializeWasm() must be awaited first!");
32593 const nativeResponseValue = wasm.TS_TxInitRbf_eq(a, b);
32594 return nativeResponseValue;
32596 // void TxAckRbf_free(struct LDKTxAckRbf this_obj);
32598 export function TxAckRbf_free(this_obj: bigint): void {
32599 if(!isWasmInitialized) {
32600 throw new Error("initializeWasm() must be awaited first!");
32602 const nativeResponseValue = wasm.TS_TxAckRbf_free(this_obj);
32603 // debug statements here
32605 // const uint8_t (*TxAckRbf_get_channel_id(const struct LDKTxAckRbf *NONNULL_PTR this_ptr))[32];
32607 export function TxAckRbf_get_channel_id(this_ptr: bigint): number {
32608 if(!isWasmInitialized) {
32609 throw new Error("initializeWasm() must be awaited first!");
32611 const nativeResponseValue = wasm.TS_TxAckRbf_get_channel_id(this_ptr);
32612 return nativeResponseValue;
32614 // void TxAckRbf_set_channel_id(struct LDKTxAckRbf *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32616 export function TxAckRbf_set_channel_id(this_ptr: bigint, val: number): void {
32617 if(!isWasmInitialized) {
32618 throw new Error("initializeWasm() must be awaited first!");
32620 const nativeResponseValue = wasm.TS_TxAckRbf_set_channel_id(this_ptr, val);
32621 // debug statements here
32623 // struct LDKCOption_i64Z TxAckRbf_get_funding_output_contribution(const struct LDKTxAckRbf *NONNULL_PTR this_ptr);
32625 export function TxAckRbf_get_funding_output_contribution(this_ptr: bigint): bigint {
32626 if(!isWasmInitialized) {
32627 throw new Error("initializeWasm() must be awaited first!");
32629 const nativeResponseValue = wasm.TS_TxAckRbf_get_funding_output_contribution(this_ptr);
32630 return nativeResponseValue;
32632 // void TxAckRbf_set_funding_output_contribution(struct LDKTxAckRbf *NONNULL_PTR this_ptr, struct LDKCOption_i64Z val);
32634 export function TxAckRbf_set_funding_output_contribution(this_ptr: bigint, val: bigint): void {
32635 if(!isWasmInitialized) {
32636 throw new Error("initializeWasm() must be awaited first!");
32638 const nativeResponseValue = wasm.TS_TxAckRbf_set_funding_output_contribution(this_ptr, val);
32639 // debug statements here
32641 // MUST_USE_RES struct LDKTxAckRbf TxAckRbf_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCOption_i64Z funding_output_contribution_arg);
32643 export function TxAckRbf_new(channel_id_arg: number, funding_output_contribution_arg: bigint): bigint {
32644 if(!isWasmInitialized) {
32645 throw new Error("initializeWasm() must be awaited first!");
32647 const nativeResponseValue = wasm.TS_TxAckRbf_new(channel_id_arg, funding_output_contribution_arg);
32648 return nativeResponseValue;
32650 // uint64_t TxAckRbf_clone_ptr(LDKTxAckRbf *NONNULL_PTR arg);
32652 export function TxAckRbf_clone_ptr(arg: bigint): bigint {
32653 if(!isWasmInitialized) {
32654 throw new Error("initializeWasm() must be awaited first!");
32656 const nativeResponseValue = wasm.TS_TxAckRbf_clone_ptr(arg);
32657 return nativeResponseValue;
32659 // struct LDKTxAckRbf TxAckRbf_clone(const struct LDKTxAckRbf *NONNULL_PTR orig);
32661 export function TxAckRbf_clone(orig: bigint): bigint {
32662 if(!isWasmInitialized) {
32663 throw new Error("initializeWasm() must be awaited first!");
32665 const nativeResponseValue = wasm.TS_TxAckRbf_clone(orig);
32666 return nativeResponseValue;
32668 // bool TxAckRbf_eq(const struct LDKTxAckRbf *NONNULL_PTR a, const struct LDKTxAckRbf *NONNULL_PTR b);
32670 export function TxAckRbf_eq(a: bigint, b: bigint): boolean {
32671 if(!isWasmInitialized) {
32672 throw new Error("initializeWasm() must be awaited first!");
32674 const nativeResponseValue = wasm.TS_TxAckRbf_eq(a, b);
32675 return nativeResponseValue;
32677 // void TxAbort_free(struct LDKTxAbort this_obj);
32679 export function TxAbort_free(this_obj: bigint): void {
32680 if(!isWasmInitialized) {
32681 throw new Error("initializeWasm() must be awaited first!");
32683 const nativeResponseValue = wasm.TS_TxAbort_free(this_obj);
32684 // debug statements here
32686 // const uint8_t (*TxAbort_get_channel_id(const struct LDKTxAbort *NONNULL_PTR this_ptr))[32];
32688 export function TxAbort_get_channel_id(this_ptr: bigint): number {
32689 if(!isWasmInitialized) {
32690 throw new Error("initializeWasm() must be awaited first!");
32692 const nativeResponseValue = wasm.TS_TxAbort_get_channel_id(this_ptr);
32693 return nativeResponseValue;
32695 // void TxAbort_set_channel_id(struct LDKTxAbort *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32697 export function TxAbort_set_channel_id(this_ptr: bigint, val: number): void {
32698 if(!isWasmInitialized) {
32699 throw new Error("initializeWasm() must be awaited first!");
32701 const nativeResponseValue = wasm.TS_TxAbort_set_channel_id(this_ptr, val);
32702 // debug statements here
32704 // struct LDKCVec_u8Z TxAbort_get_data(const struct LDKTxAbort *NONNULL_PTR this_ptr);
32706 export function TxAbort_get_data(this_ptr: bigint): number {
32707 if(!isWasmInitialized) {
32708 throw new Error("initializeWasm() must be awaited first!");
32710 const nativeResponseValue = wasm.TS_TxAbort_get_data(this_ptr);
32711 return nativeResponseValue;
32713 // void TxAbort_set_data(struct LDKTxAbort *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
32715 export function TxAbort_set_data(this_ptr: bigint, val: number): void {
32716 if(!isWasmInitialized) {
32717 throw new Error("initializeWasm() must be awaited first!");
32719 const nativeResponseValue = wasm.TS_TxAbort_set_data(this_ptr, val);
32720 // debug statements here
32722 // MUST_USE_RES struct LDKTxAbort TxAbort_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z data_arg);
32724 export function TxAbort_new(channel_id_arg: number, data_arg: number): bigint {
32725 if(!isWasmInitialized) {
32726 throw new Error("initializeWasm() must be awaited first!");
32728 const nativeResponseValue = wasm.TS_TxAbort_new(channel_id_arg, data_arg);
32729 return nativeResponseValue;
32731 // uint64_t TxAbort_clone_ptr(LDKTxAbort *NONNULL_PTR arg);
32733 export function TxAbort_clone_ptr(arg: bigint): bigint {
32734 if(!isWasmInitialized) {
32735 throw new Error("initializeWasm() must be awaited first!");
32737 const nativeResponseValue = wasm.TS_TxAbort_clone_ptr(arg);
32738 return nativeResponseValue;
32740 // struct LDKTxAbort TxAbort_clone(const struct LDKTxAbort *NONNULL_PTR orig);
32742 export function TxAbort_clone(orig: bigint): bigint {
32743 if(!isWasmInitialized) {
32744 throw new Error("initializeWasm() must be awaited first!");
32746 const nativeResponseValue = wasm.TS_TxAbort_clone(orig);
32747 return nativeResponseValue;
32749 // bool TxAbort_eq(const struct LDKTxAbort *NONNULL_PTR a, const struct LDKTxAbort *NONNULL_PTR b);
32751 export function TxAbort_eq(a: bigint, b: bigint): boolean {
32752 if(!isWasmInitialized) {
32753 throw new Error("initializeWasm() must be awaited first!");
32755 const nativeResponseValue = wasm.TS_TxAbort_eq(a, b);
32756 return nativeResponseValue;
32758 // void Shutdown_free(struct LDKShutdown this_obj);
32760 export function Shutdown_free(this_obj: bigint): void {
32761 if(!isWasmInitialized) {
32762 throw new Error("initializeWasm() must be awaited first!");
32764 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
32765 // debug statements here
32767 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
32769 export function Shutdown_get_channel_id(this_ptr: bigint): number {
32770 if(!isWasmInitialized) {
32771 throw new Error("initializeWasm() must be awaited first!");
32773 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
32774 return nativeResponseValue;
32776 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32778 export function Shutdown_set_channel_id(this_ptr: bigint, val: number): void {
32779 if(!isWasmInitialized) {
32780 throw new Error("initializeWasm() must be awaited first!");
32782 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
32783 // debug statements here
32785 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
32787 export function Shutdown_get_scriptpubkey(this_ptr: bigint): number {
32788 if(!isWasmInitialized) {
32789 throw new Error("initializeWasm() must be awaited first!");
32791 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
32792 return nativeResponseValue;
32794 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
32796 export function Shutdown_set_scriptpubkey(this_ptr: bigint, val: number): void {
32797 if(!isWasmInitialized) {
32798 throw new Error("initializeWasm() must be awaited first!");
32800 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
32801 // debug statements here
32803 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
32805 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): bigint {
32806 if(!isWasmInitialized) {
32807 throw new Error("initializeWasm() must be awaited first!");
32809 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
32810 return nativeResponseValue;
32812 // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
32814 export function Shutdown_clone_ptr(arg: bigint): bigint {
32815 if(!isWasmInitialized) {
32816 throw new Error("initializeWasm() must be awaited first!");
32818 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
32819 return nativeResponseValue;
32821 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
32823 export function Shutdown_clone(orig: bigint): bigint {
32824 if(!isWasmInitialized) {
32825 throw new Error("initializeWasm() must be awaited first!");
32827 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
32828 return nativeResponseValue;
32830 // bool Shutdown_eq(const struct LDKShutdown *NONNULL_PTR a, const struct LDKShutdown *NONNULL_PTR b);
32832 export function Shutdown_eq(a: bigint, b: bigint): boolean {
32833 if(!isWasmInitialized) {
32834 throw new Error("initializeWasm() must be awaited first!");
32836 const nativeResponseValue = wasm.TS_Shutdown_eq(a, b);
32837 return nativeResponseValue;
32839 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
32841 export function ClosingSignedFeeRange_free(this_obj: bigint): void {
32842 if(!isWasmInitialized) {
32843 throw new Error("initializeWasm() must be awaited first!");
32845 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
32846 // debug statements here
32848 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
32850 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: bigint): bigint {
32851 if(!isWasmInitialized) {
32852 throw new Error("initializeWasm() must be awaited first!");
32854 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
32855 return nativeResponseValue;
32857 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
32859 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: bigint, val: bigint): void {
32860 if(!isWasmInitialized) {
32861 throw new Error("initializeWasm() must be awaited first!");
32863 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
32864 // debug statements here
32866 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
32868 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: bigint): bigint {
32869 if(!isWasmInitialized) {
32870 throw new Error("initializeWasm() must be awaited first!");
32872 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
32873 return nativeResponseValue;
32875 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
32877 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
32878 if(!isWasmInitialized) {
32879 throw new Error("initializeWasm() must be awaited first!");
32881 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
32882 // debug statements here
32884 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
32886 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): bigint {
32887 if(!isWasmInitialized) {
32888 throw new Error("initializeWasm() must be awaited first!");
32890 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
32891 return nativeResponseValue;
32893 // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
32895 export function ClosingSignedFeeRange_clone_ptr(arg: bigint): bigint {
32896 if(!isWasmInitialized) {
32897 throw new Error("initializeWasm() must be awaited first!");
32899 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
32900 return nativeResponseValue;
32902 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
32904 export function ClosingSignedFeeRange_clone(orig: bigint): bigint {
32905 if(!isWasmInitialized) {
32906 throw new Error("initializeWasm() must be awaited first!");
32908 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
32909 return nativeResponseValue;
32911 // bool ClosingSignedFeeRange_eq(const struct LDKClosingSignedFeeRange *NONNULL_PTR a, const struct LDKClosingSignedFeeRange *NONNULL_PTR b);
32913 export function ClosingSignedFeeRange_eq(a: bigint, b: bigint): boolean {
32914 if(!isWasmInitialized) {
32915 throw new Error("initializeWasm() must be awaited first!");
32917 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_eq(a, b);
32918 return nativeResponseValue;
32920 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
32922 export function ClosingSigned_free(this_obj: bigint): void {
32923 if(!isWasmInitialized) {
32924 throw new Error("initializeWasm() must be awaited first!");
32926 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
32927 // debug statements here
32929 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
32931 export function ClosingSigned_get_channel_id(this_ptr: bigint): number {
32932 if(!isWasmInitialized) {
32933 throw new Error("initializeWasm() must be awaited first!");
32935 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
32936 return nativeResponseValue;
32938 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32940 export function ClosingSigned_set_channel_id(this_ptr: bigint, val: number): void {
32941 if(!isWasmInitialized) {
32942 throw new Error("initializeWasm() must be awaited first!");
32944 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
32945 // debug statements here
32947 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
32949 export function ClosingSigned_get_fee_satoshis(this_ptr: bigint): bigint {
32950 if(!isWasmInitialized) {
32951 throw new Error("initializeWasm() must be awaited first!");
32953 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
32954 return nativeResponseValue;
32956 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
32958 export function ClosingSigned_set_fee_satoshis(this_ptr: bigint, val: bigint): void {
32959 if(!isWasmInitialized) {
32960 throw new Error("initializeWasm() must be awaited first!");
32962 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
32963 // debug statements here
32965 // struct LDKECDSASignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
32967 export function ClosingSigned_get_signature(this_ptr: bigint): number {
32968 if(!isWasmInitialized) {
32969 throw new Error("initializeWasm() must be awaited first!");
32971 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
32972 return nativeResponseValue;
32974 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
32976 export function ClosingSigned_set_signature(this_ptr: bigint, val: number): void {
32977 if(!isWasmInitialized) {
32978 throw new Error("initializeWasm() must be awaited first!");
32980 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
32981 // debug statements here
32983 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
32985 export function ClosingSigned_get_fee_range(this_ptr: bigint): bigint {
32986 if(!isWasmInitialized) {
32987 throw new Error("initializeWasm() must be awaited first!");
32989 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
32990 return nativeResponseValue;
32992 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
32994 export function ClosingSigned_set_fee_range(this_ptr: bigint, val: bigint): void {
32995 if(!isWasmInitialized) {
32996 throw new Error("initializeWasm() must be awaited first!");
32998 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
32999 // debug statements here
33001 // MUST_USE_RES struct LDKClosingSigned ClosingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t fee_satoshis_arg, struct LDKECDSASignature signature_arg, struct LDKClosingSignedFeeRange fee_range_arg);
33003 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: bigint): bigint {
33004 if(!isWasmInitialized) {
33005 throw new Error("initializeWasm() must be awaited first!");
33007 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
33008 return nativeResponseValue;
33010 // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
33012 export function ClosingSigned_clone_ptr(arg: bigint): bigint {
33013 if(!isWasmInitialized) {
33014 throw new Error("initializeWasm() must be awaited first!");
33016 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
33017 return nativeResponseValue;
33019 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
33021 export function ClosingSigned_clone(orig: bigint): bigint {
33022 if(!isWasmInitialized) {
33023 throw new Error("initializeWasm() must be awaited first!");
33025 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
33026 return nativeResponseValue;
33028 // bool ClosingSigned_eq(const struct LDKClosingSigned *NONNULL_PTR a, const struct LDKClosingSigned *NONNULL_PTR b);
33030 export function ClosingSigned_eq(a: bigint, b: bigint): boolean {
33031 if(!isWasmInitialized) {
33032 throw new Error("initializeWasm() must be awaited first!");
33034 const nativeResponseValue = wasm.TS_ClosingSigned_eq(a, b);
33035 return nativeResponseValue;
33037 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
33039 export function UpdateAddHTLC_free(this_obj: bigint): void {
33040 if(!isWasmInitialized) {
33041 throw new Error("initializeWasm() must be awaited first!");
33043 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
33044 // debug statements here
33046 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
33048 export function UpdateAddHTLC_get_channel_id(this_ptr: bigint): number {
33049 if(!isWasmInitialized) {
33050 throw new Error("initializeWasm() must be awaited first!");
33052 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
33053 return nativeResponseValue;
33055 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33057 export function UpdateAddHTLC_set_channel_id(this_ptr: bigint, val: number): void {
33058 if(!isWasmInitialized) {
33059 throw new Error("initializeWasm() must be awaited first!");
33061 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
33062 // debug statements here
33064 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
33066 export function UpdateAddHTLC_get_htlc_id(this_ptr: bigint): bigint {
33067 if(!isWasmInitialized) {
33068 throw new Error("initializeWasm() must be awaited first!");
33070 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
33071 return nativeResponseValue;
33073 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
33075 export function UpdateAddHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
33076 if(!isWasmInitialized) {
33077 throw new Error("initializeWasm() must be awaited first!");
33079 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
33080 // debug statements here
33082 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
33084 export function UpdateAddHTLC_get_amount_msat(this_ptr: bigint): bigint {
33085 if(!isWasmInitialized) {
33086 throw new Error("initializeWasm() must be awaited first!");
33088 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
33089 return nativeResponseValue;
33091 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
33093 export function UpdateAddHTLC_set_amount_msat(this_ptr: bigint, val: bigint): void {
33094 if(!isWasmInitialized) {
33095 throw new Error("initializeWasm() must be awaited first!");
33097 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
33098 // debug statements here
33100 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
33102 export function UpdateAddHTLC_get_payment_hash(this_ptr: bigint): number {
33103 if(!isWasmInitialized) {
33104 throw new Error("initializeWasm() must be awaited first!");
33106 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
33107 return nativeResponseValue;
33109 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33111 export function UpdateAddHTLC_set_payment_hash(this_ptr: bigint, val: number): void {
33112 if(!isWasmInitialized) {
33113 throw new Error("initializeWasm() must be awaited first!");
33115 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
33116 // debug statements here
33118 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
33120 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: bigint): number {
33121 if(!isWasmInitialized) {
33122 throw new Error("initializeWasm() must be awaited first!");
33124 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
33125 return nativeResponseValue;
33127 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
33129 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
33130 if(!isWasmInitialized) {
33131 throw new Error("initializeWasm() must be awaited first!");
33133 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
33134 // debug statements here
33136 // struct LDKCOption_u64Z UpdateAddHTLC_get_skimmed_fee_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
33138 export function UpdateAddHTLC_get_skimmed_fee_msat(this_ptr: bigint): bigint {
33139 if(!isWasmInitialized) {
33140 throw new Error("initializeWasm() must be awaited first!");
33142 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_skimmed_fee_msat(this_ptr);
33143 return nativeResponseValue;
33145 // void UpdateAddHTLC_set_skimmed_fee_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
33147 export function UpdateAddHTLC_set_skimmed_fee_msat(this_ptr: bigint, val: bigint): void {
33148 if(!isWasmInitialized) {
33149 throw new Error("initializeWasm() must be awaited first!");
33151 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_skimmed_fee_msat(this_ptr, val);
33152 // debug statements here
33154 // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
33156 export function UpdateAddHTLC_clone_ptr(arg: bigint): bigint {
33157 if(!isWasmInitialized) {
33158 throw new Error("initializeWasm() must be awaited first!");
33160 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
33161 return nativeResponseValue;
33163 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
33165 export function UpdateAddHTLC_clone(orig: bigint): bigint {
33166 if(!isWasmInitialized) {
33167 throw new Error("initializeWasm() must be awaited first!");
33169 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
33170 return nativeResponseValue;
33172 // bool UpdateAddHTLC_eq(const struct LDKUpdateAddHTLC *NONNULL_PTR a, const struct LDKUpdateAddHTLC *NONNULL_PTR b);
33174 export function UpdateAddHTLC_eq(a: bigint, b: bigint): boolean {
33175 if(!isWasmInitialized) {
33176 throw new Error("initializeWasm() must be awaited first!");
33178 const nativeResponseValue = wasm.TS_UpdateAddHTLC_eq(a, b);
33179 return nativeResponseValue;
33181 // void OnionMessage_free(struct LDKOnionMessage this_obj);
33183 export function OnionMessage_free(this_obj: bigint): void {
33184 if(!isWasmInitialized) {
33185 throw new Error("initializeWasm() must be awaited first!");
33187 const nativeResponseValue = wasm.TS_OnionMessage_free(this_obj);
33188 // debug statements here
33190 // struct LDKPublicKey OnionMessage_get_blinding_point(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
33192 export function OnionMessage_get_blinding_point(this_ptr: bigint): number {
33193 if(!isWasmInitialized) {
33194 throw new Error("initializeWasm() must be awaited first!");
33196 const nativeResponseValue = wasm.TS_OnionMessage_get_blinding_point(this_ptr);
33197 return nativeResponseValue;
33199 // void OnionMessage_set_blinding_point(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33201 export function OnionMessage_set_blinding_point(this_ptr: bigint, val: number): void {
33202 if(!isWasmInitialized) {
33203 throw new Error("initializeWasm() must be awaited first!");
33205 const nativeResponseValue = wasm.TS_OnionMessage_set_blinding_point(this_ptr, val);
33206 // debug statements here
33208 // struct LDKPacket OnionMessage_get_onion_routing_packet(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
33210 export function OnionMessage_get_onion_routing_packet(this_ptr: bigint): bigint {
33211 if(!isWasmInitialized) {
33212 throw new Error("initializeWasm() must be awaited first!");
33214 const nativeResponseValue = wasm.TS_OnionMessage_get_onion_routing_packet(this_ptr);
33215 return nativeResponseValue;
33217 // void OnionMessage_set_onion_routing_packet(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPacket val);
33219 export function OnionMessage_set_onion_routing_packet(this_ptr: bigint, val: bigint): void {
33220 if(!isWasmInitialized) {
33221 throw new Error("initializeWasm() must be awaited first!");
33223 const nativeResponseValue = wasm.TS_OnionMessage_set_onion_routing_packet(this_ptr, val);
33224 // debug statements here
33226 // MUST_USE_RES struct LDKOnionMessage OnionMessage_new(struct LDKPublicKey blinding_point_arg, struct LDKPacket onion_routing_packet_arg);
33228 export function OnionMessage_new(blinding_point_arg: number, onion_routing_packet_arg: bigint): bigint {
33229 if(!isWasmInitialized) {
33230 throw new Error("initializeWasm() must be awaited first!");
33232 const nativeResponseValue = wasm.TS_OnionMessage_new(blinding_point_arg, onion_routing_packet_arg);
33233 return nativeResponseValue;
33235 // uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg);
33237 export function OnionMessage_clone_ptr(arg: bigint): bigint {
33238 if(!isWasmInitialized) {
33239 throw new Error("initializeWasm() must be awaited first!");
33241 const nativeResponseValue = wasm.TS_OnionMessage_clone_ptr(arg);
33242 return nativeResponseValue;
33244 // struct LDKOnionMessage OnionMessage_clone(const struct LDKOnionMessage *NONNULL_PTR orig);
33246 export function OnionMessage_clone(orig: bigint): bigint {
33247 if(!isWasmInitialized) {
33248 throw new Error("initializeWasm() must be awaited first!");
33250 const nativeResponseValue = wasm.TS_OnionMessage_clone(orig);
33251 return nativeResponseValue;
33253 // bool OnionMessage_eq(const struct LDKOnionMessage *NONNULL_PTR a, const struct LDKOnionMessage *NONNULL_PTR b);
33255 export function OnionMessage_eq(a: bigint, b: bigint): boolean {
33256 if(!isWasmInitialized) {
33257 throw new Error("initializeWasm() must be awaited first!");
33259 const nativeResponseValue = wasm.TS_OnionMessage_eq(a, b);
33260 return nativeResponseValue;
33262 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
33264 export function UpdateFulfillHTLC_free(this_obj: bigint): void {
33265 if(!isWasmInitialized) {
33266 throw new Error("initializeWasm() must be awaited first!");
33268 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
33269 // debug statements here
33271 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
33273 export function UpdateFulfillHTLC_get_channel_id(this_ptr: bigint): number {
33274 if(!isWasmInitialized) {
33275 throw new Error("initializeWasm() must be awaited first!");
33277 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
33278 return nativeResponseValue;
33280 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33282 export function UpdateFulfillHTLC_set_channel_id(this_ptr: bigint, val: number): void {
33283 if(!isWasmInitialized) {
33284 throw new Error("initializeWasm() must be awaited first!");
33286 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
33287 // debug statements here
33289 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
33291 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: bigint): bigint {
33292 if(!isWasmInitialized) {
33293 throw new Error("initializeWasm() must be awaited first!");
33295 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
33296 return nativeResponseValue;
33298 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
33300 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
33301 if(!isWasmInitialized) {
33302 throw new Error("initializeWasm() must be awaited first!");
33304 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
33305 // debug statements here
33307 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
33309 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: bigint): number {
33310 if(!isWasmInitialized) {
33311 throw new Error("initializeWasm() must be awaited first!");
33313 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
33314 return nativeResponseValue;
33316 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33318 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: bigint, val: number): void {
33319 if(!isWasmInitialized) {
33320 throw new Error("initializeWasm() must be awaited first!");
33322 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
33323 // debug statements here
33325 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
33327 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): bigint {
33328 if(!isWasmInitialized) {
33329 throw new Error("initializeWasm() must be awaited first!");
33331 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
33332 return nativeResponseValue;
33334 // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
33336 export function UpdateFulfillHTLC_clone_ptr(arg: bigint): bigint {
33337 if(!isWasmInitialized) {
33338 throw new Error("initializeWasm() must be awaited first!");
33340 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
33341 return nativeResponseValue;
33343 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
33345 export function UpdateFulfillHTLC_clone(orig: bigint): bigint {
33346 if(!isWasmInitialized) {
33347 throw new Error("initializeWasm() must be awaited first!");
33349 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
33350 return nativeResponseValue;
33352 // bool UpdateFulfillHTLC_eq(const struct LDKUpdateFulfillHTLC *NONNULL_PTR a, const struct LDKUpdateFulfillHTLC *NONNULL_PTR b);
33354 export function UpdateFulfillHTLC_eq(a: bigint, b: bigint): boolean {
33355 if(!isWasmInitialized) {
33356 throw new Error("initializeWasm() must be awaited first!");
33358 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_eq(a, b);
33359 return nativeResponseValue;
33361 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
33363 export function UpdateFailHTLC_free(this_obj: bigint): void {
33364 if(!isWasmInitialized) {
33365 throw new Error("initializeWasm() must be awaited first!");
33367 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
33368 // debug statements here
33370 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
33372 export function UpdateFailHTLC_get_channel_id(this_ptr: bigint): number {
33373 if(!isWasmInitialized) {
33374 throw new Error("initializeWasm() must be awaited first!");
33376 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
33377 return nativeResponseValue;
33379 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33381 export function UpdateFailHTLC_set_channel_id(this_ptr: bigint, val: number): void {
33382 if(!isWasmInitialized) {
33383 throw new Error("initializeWasm() must be awaited first!");
33385 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
33386 // debug statements here
33388 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
33390 export function UpdateFailHTLC_get_htlc_id(this_ptr: bigint): bigint {
33391 if(!isWasmInitialized) {
33392 throw new Error("initializeWasm() must be awaited first!");
33394 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
33395 return nativeResponseValue;
33397 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
33399 export function UpdateFailHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
33400 if(!isWasmInitialized) {
33401 throw new Error("initializeWasm() must be awaited first!");
33403 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
33404 // debug statements here
33406 // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
33408 export function UpdateFailHTLC_clone_ptr(arg: bigint): bigint {
33409 if(!isWasmInitialized) {
33410 throw new Error("initializeWasm() must be awaited first!");
33412 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
33413 return nativeResponseValue;
33415 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
33417 export function UpdateFailHTLC_clone(orig: bigint): bigint {
33418 if(!isWasmInitialized) {
33419 throw new Error("initializeWasm() must be awaited first!");
33421 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
33422 return nativeResponseValue;
33424 // bool UpdateFailHTLC_eq(const struct LDKUpdateFailHTLC *NONNULL_PTR a, const struct LDKUpdateFailHTLC *NONNULL_PTR b);
33426 export function UpdateFailHTLC_eq(a: bigint, b: bigint): boolean {
33427 if(!isWasmInitialized) {
33428 throw new Error("initializeWasm() must be awaited first!");
33430 const nativeResponseValue = wasm.TS_UpdateFailHTLC_eq(a, b);
33431 return nativeResponseValue;
33433 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
33435 export function UpdateFailMalformedHTLC_free(this_obj: bigint): void {
33436 if(!isWasmInitialized) {
33437 throw new Error("initializeWasm() must be awaited first!");
33439 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
33440 // debug statements here
33442 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
33444 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: bigint): number {
33445 if(!isWasmInitialized) {
33446 throw new Error("initializeWasm() must be awaited first!");
33448 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
33449 return nativeResponseValue;
33451 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33453 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
33454 if(!isWasmInitialized) {
33455 throw new Error("initializeWasm() must be awaited first!");
33457 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
33458 // debug statements here
33460 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
33462 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: bigint): bigint {
33463 if(!isWasmInitialized) {
33464 throw new Error("initializeWasm() must be awaited first!");
33466 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
33467 return nativeResponseValue;
33469 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
33471 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
33472 if(!isWasmInitialized) {
33473 throw new Error("initializeWasm() must be awaited first!");
33475 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
33476 // debug statements here
33478 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
33480 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: bigint): number {
33481 if(!isWasmInitialized) {
33482 throw new Error("initializeWasm() must be awaited first!");
33484 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
33485 return nativeResponseValue;
33487 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
33489 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: bigint, val: number): void {
33490 if(!isWasmInitialized) {
33491 throw new Error("initializeWasm() must be awaited first!");
33493 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
33494 // debug statements here
33496 // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
33498 export function UpdateFailMalformedHTLC_clone_ptr(arg: bigint): bigint {
33499 if(!isWasmInitialized) {
33500 throw new Error("initializeWasm() must be awaited first!");
33502 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
33503 return nativeResponseValue;
33505 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
33507 export function UpdateFailMalformedHTLC_clone(orig: bigint): bigint {
33508 if(!isWasmInitialized) {
33509 throw new Error("initializeWasm() must be awaited first!");
33511 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
33512 return nativeResponseValue;
33514 // bool UpdateFailMalformedHTLC_eq(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR a, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR b);
33516 export function UpdateFailMalformedHTLC_eq(a: bigint, b: bigint): boolean {
33517 if(!isWasmInitialized) {
33518 throw new Error("initializeWasm() must be awaited first!");
33520 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_eq(a, b);
33521 return nativeResponseValue;
33523 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
33525 export function CommitmentSigned_free(this_obj: bigint): void {
33526 if(!isWasmInitialized) {
33527 throw new Error("initializeWasm() must be awaited first!");
33529 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
33530 // debug statements here
33532 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
33534 export function CommitmentSigned_get_channel_id(this_ptr: bigint): number {
33535 if(!isWasmInitialized) {
33536 throw new Error("initializeWasm() must be awaited first!");
33538 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
33539 return nativeResponseValue;
33541 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33543 export function CommitmentSigned_set_channel_id(this_ptr: bigint, val: number): void {
33544 if(!isWasmInitialized) {
33545 throw new Error("initializeWasm() must be awaited first!");
33547 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
33548 // debug statements here
33550 // struct LDKECDSASignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
33552 export function CommitmentSigned_get_signature(this_ptr: bigint): number {
33553 if(!isWasmInitialized) {
33554 throw new Error("initializeWasm() must be awaited first!");
33556 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
33557 return nativeResponseValue;
33559 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
33561 export function CommitmentSigned_set_signature(this_ptr: bigint, val: number): void {
33562 if(!isWasmInitialized) {
33563 throw new Error("initializeWasm() must be awaited first!");
33565 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
33566 // debug statements here
33568 // struct LDKCVec_ECDSASignatureZ CommitmentSigned_get_htlc_signatures(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
33570 export function CommitmentSigned_get_htlc_signatures(this_ptr: bigint): number {
33571 if(!isWasmInitialized) {
33572 throw new Error("initializeWasm() must be awaited first!");
33574 const nativeResponseValue = wasm.TS_CommitmentSigned_get_htlc_signatures(this_ptr);
33575 return nativeResponseValue;
33577 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_ECDSASignatureZ val);
33579 export function CommitmentSigned_set_htlc_signatures(this_ptr: bigint, val: number): void {
33580 if(!isWasmInitialized) {
33581 throw new Error("initializeWasm() must be awaited first!");
33583 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
33584 // debug statements here
33586 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKECDSASignature signature_arg, struct LDKCVec_ECDSASignatureZ htlc_signatures_arg);
33588 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): bigint {
33589 if(!isWasmInitialized) {
33590 throw new Error("initializeWasm() must be awaited first!");
33592 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
33593 return nativeResponseValue;
33595 // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
33597 export function CommitmentSigned_clone_ptr(arg: bigint): bigint {
33598 if(!isWasmInitialized) {
33599 throw new Error("initializeWasm() must be awaited first!");
33601 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
33602 return nativeResponseValue;
33604 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
33606 export function CommitmentSigned_clone(orig: bigint): bigint {
33607 if(!isWasmInitialized) {
33608 throw new Error("initializeWasm() must be awaited first!");
33610 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
33611 return nativeResponseValue;
33613 // bool CommitmentSigned_eq(const struct LDKCommitmentSigned *NONNULL_PTR a, const struct LDKCommitmentSigned *NONNULL_PTR b);
33615 export function CommitmentSigned_eq(a: bigint, b: bigint): boolean {
33616 if(!isWasmInitialized) {
33617 throw new Error("initializeWasm() must be awaited first!");
33619 const nativeResponseValue = wasm.TS_CommitmentSigned_eq(a, b);
33620 return nativeResponseValue;
33622 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
33624 export function RevokeAndACK_free(this_obj: bigint): void {
33625 if(!isWasmInitialized) {
33626 throw new Error("initializeWasm() must be awaited first!");
33628 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
33629 // debug statements here
33631 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
33633 export function RevokeAndACK_get_channel_id(this_ptr: bigint): number {
33634 if(!isWasmInitialized) {
33635 throw new Error("initializeWasm() must be awaited first!");
33637 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
33638 return nativeResponseValue;
33640 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33642 export function RevokeAndACK_set_channel_id(this_ptr: bigint, val: number): void {
33643 if(!isWasmInitialized) {
33644 throw new Error("initializeWasm() must be awaited first!");
33646 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
33647 // debug statements here
33649 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
33651 export function RevokeAndACK_get_per_commitment_secret(this_ptr: bigint): number {
33652 if(!isWasmInitialized) {
33653 throw new Error("initializeWasm() must be awaited first!");
33655 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
33656 return nativeResponseValue;
33658 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33660 export function RevokeAndACK_set_per_commitment_secret(this_ptr: bigint, val: number): void {
33661 if(!isWasmInitialized) {
33662 throw new Error("initializeWasm() must be awaited first!");
33664 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
33665 // debug statements here
33667 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
33669 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: bigint): number {
33670 if(!isWasmInitialized) {
33671 throw new Error("initializeWasm() must be awaited first!");
33673 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
33674 return nativeResponseValue;
33676 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33678 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
33679 if(!isWasmInitialized) {
33680 throw new Error("initializeWasm() must be awaited first!");
33682 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
33683 // debug statements here
33685 // MUST_USE_RES struct LDKRevokeAndACK RevokeAndACK_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKThirtyTwoBytes per_commitment_secret_arg, struct LDKPublicKey next_per_commitment_point_arg);
33687 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): bigint {
33688 if(!isWasmInitialized) {
33689 throw new Error("initializeWasm() must be awaited first!");
33691 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
33692 return nativeResponseValue;
33694 // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
33696 export function RevokeAndACK_clone_ptr(arg: bigint): bigint {
33697 if(!isWasmInitialized) {
33698 throw new Error("initializeWasm() must be awaited first!");
33700 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
33701 return nativeResponseValue;
33703 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
33705 export function RevokeAndACK_clone(orig: bigint): bigint {
33706 if(!isWasmInitialized) {
33707 throw new Error("initializeWasm() must be awaited first!");
33709 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
33710 return nativeResponseValue;
33712 // bool RevokeAndACK_eq(const struct LDKRevokeAndACK *NONNULL_PTR a, const struct LDKRevokeAndACK *NONNULL_PTR b);
33714 export function RevokeAndACK_eq(a: bigint, b: bigint): boolean {
33715 if(!isWasmInitialized) {
33716 throw new Error("initializeWasm() must be awaited first!");
33718 const nativeResponseValue = wasm.TS_RevokeAndACK_eq(a, b);
33719 return nativeResponseValue;
33721 // void UpdateFee_free(struct LDKUpdateFee this_obj);
33723 export function UpdateFee_free(this_obj: bigint): void {
33724 if(!isWasmInitialized) {
33725 throw new Error("initializeWasm() must be awaited first!");
33727 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
33728 // debug statements here
33730 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
33732 export function UpdateFee_get_channel_id(this_ptr: bigint): number {
33733 if(!isWasmInitialized) {
33734 throw new Error("initializeWasm() must be awaited first!");
33736 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
33737 return nativeResponseValue;
33739 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33741 export function UpdateFee_set_channel_id(this_ptr: bigint, val: number): void {
33742 if(!isWasmInitialized) {
33743 throw new Error("initializeWasm() must be awaited first!");
33745 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
33746 // debug statements here
33748 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
33750 export function UpdateFee_get_feerate_per_kw(this_ptr: bigint): number {
33751 if(!isWasmInitialized) {
33752 throw new Error("initializeWasm() must be awaited first!");
33754 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
33755 return nativeResponseValue;
33757 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
33759 export function UpdateFee_set_feerate_per_kw(this_ptr: bigint, val: number): void {
33760 if(!isWasmInitialized) {
33761 throw new Error("initializeWasm() must be awaited first!");
33763 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
33764 // debug statements here
33766 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
33768 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): bigint {
33769 if(!isWasmInitialized) {
33770 throw new Error("initializeWasm() must be awaited first!");
33772 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
33773 return nativeResponseValue;
33775 // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
33777 export function UpdateFee_clone_ptr(arg: bigint): bigint {
33778 if(!isWasmInitialized) {
33779 throw new Error("initializeWasm() must be awaited first!");
33781 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
33782 return nativeResponseValue;
33784 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
33786 export function UpdateFee_clone(orig: bigint): bigint {
33787 if(!isWasmInitialized) {
33788 throw new Error("initializeWasm() must be awaited first!");
33790 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
33791 return nativeResponseValue;
33793 // bool UpdateFee_eq(const struct LDKUpdateFee *NONNULL_PTR a, const struct LDKUpdateFee *NONNULL_PTR b);
33795 export function UpdateFee_eq(a: bigint, b: bigint): boolean {
33796 if(!isWasmInitialized) {
33797 throw new Error("initializeWasm() must be awaited first!");
33799 const nativeResponseValue = wasm.TS_UpdateFee_eq(a, b);
33800 return nativeResponseValue;
33802 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
33804 export function ChannelReestablish_free(this_obj: bigint): void {
33805 if(!isWasmInitialized) {
33806 throw new Error("initializeWasm() must be awaited first!");
33808 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
33809 // debug statements here
33811 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
33813 export function ChannelReestablish_get_channel_id(this_ptr: bigint): number {
33814 if(!isWasmInitialized) {
33815 throw new Error("initializeWasm() must be awaited first!");
33817 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
33818 return nativeResponseValue;
33820 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33822 export function ChannelReestablish_set_channel_id(this_ptr: bigint, val: number): void {
33823 if(!isWasmInitialized) {
33824 throw new Error("initializeWasm() must be awaited first!");
33826 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
33827 // debug statements here
33829 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
33831 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: bigint): bigint {
33832 if(!isWasmInitialized) {
33833 throw new Error("initializeWasm() must be awaited first!");
33835 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
33836 return nativeResponseValue;
33838 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
33840 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: bigint, val: bigint): void {
33841 if(!isWasmInitialized) {
33842 throw new Error("initializeWasm() must be awaited first!");
33844 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
33845 // debug statements here
33847 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
33849 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: bigint): bigint {
33850 if(!isWasmInitialized) {
33851 throw new Error("initializeWasm() must be awaited first!");
33853 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
33854 return nativeResponseValue;
33856 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
33858 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: bigint, val: bigint): void {
33859 if(!isWasmInitialized) {
33860 throw new Error("initializeWasm() must be awaited first!");
33862 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
33863 // debug statements here
33865 // const uint8_t (*ChannelReestablish_get_your_last_per_commitment_secret(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
33867 export function ChannelReestablish_get_your_last_per_commitment_secret(this_ptr: bigint): number {
33868 if(!isWasmInitialized) {
33869 throw new Error("initializeWasm() must be awaited first!");
33871 const nativeResponseValue = wasm.TS_ChannelReestablish_get_your_last_per_commitment_secret(this_ptr);
33872 return nativeResponseValue;
33874 // void ChannelReestablish_set_your_last_per_commitment_secret(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33876 export function ChannelReestablish_set_your_last_per_commitment_secret(this_ptr: bigint, val: number): void {
33877 if(!isWasmInitialized) {
33878 throw new Error("initializeWasm() must be awaited first!");
33880 const nativeResponseValue = wasm.TS_ChannelReestablish_set_your_last_per_commitment_secret(this_ptr, val);
33881 // debug statements here
33883 // struct LDKPublicKey ChannelReestablish_get_my_current_per_commitment_point(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
33885 export function ChannelReestablish_get_my_current_per_commitment_point(this_ptr: bigint): number {
33886 if(!isWasmInitialized) {
33887 throw new Error("initializeWasm() must be awaited first!");
33889 const nativeResponseValue = wasm.TS_ChannelReestablish_get_my_current_per_commitment_point(this_ptr);
33890 return nativeResponseValue;
33892 // void ChannelReestablish_set_my_current_per_commitment_point(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33894 export function ChannelReestablish_set_my_current_per_commitment_point(this_ptr: bigint, val: number): void {
33895 if(!isWasmInitialized) {
33896 throw new Error("initializeWasm() must be awaited first!");
33898 const nativeResponseValue = wasm.TS_ChannelReestablish_set_my_current_per_commitment_point(this_ptr, val);
33899 // debug statements here
33901 // struct LDKCOption_ThirtyTwoBytesZ ChannelReestablish_get_next_funding_txid(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
33903 export function ChannelReestablish_get_next_funding_txid(this_ptr: bigint): bigint {
33904 if(!isWasmInitialized) {
33905 throw new Error("initializeWasm() must be awaited first!");
33907 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_funding_txid(this_ptr);
33908 return nativeResponseValue;
33910 // void ChannelReestablish_set_next_funding_txid(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
33912 export function ChannelReestablish_set_next_funding_txid(this_ptr: bigint, val: bigint): void {
33913 if(!isWasmInitialized) {
33914 throw new Error("initializeWasm() must be awaited first!");
33916 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_funding_txid(this_ptr, val);
33917 // debug statements here
33919 // MUST_USE_RES struct LDKChannelReestablish ChannelReestablish_new(struct LDKThirtyTwoBytes 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);
33921 export function ChannelReestablish_new(channel_id_arg: number, 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 {
33922 if(!isWasmInitialized) {
33923 throw new Error("initializeWasm() must be awaited first!");
33925 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);
33926 return nativeResponseValue;
33928 // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
33930 export function ChannelReestablish_clone_ptr(arg: bigint): bigint {
33931 if(!isWasmInitialized) {
33932 throw new Error("initializeWasm() must be awaited first!");
33934 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
33935 return nativeResponseValue;
33937 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
33939 export function ChannelReestablish_clone(orig: bigint): bigint {
33940 if(!isWasmInitialized) {
33941 throw new Error("initializeWasm() must be awaited first!");
33943 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
33944 return nativeResponseValue;
33946 // bool ChannelReestablish_eq(const struct LDKChannelReestablish *NONNULL_PTR a, const struct LDKChannelReestablish *NONNULL_PTR b);
33948 export function ChannelReestablish_eq(a: bigint, b: bigint): boolean {
33949 if(!isWasmInitialized) {
33950 throw new Error("initializeWasm() must be awaited first!");
33952 const nativeResponseValue = wasm.TS_ChannelReestablish_eq(a, b);
33953 return nativeResponseValue;
33955 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
33957 export function AnnouncementSignatures_free(this_obj: bigint): void {
33958 if(!isWasmInitialized) {
33959 throw new Error("initializeWasm() must be awaited first!");
33961 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
33962 // debug statements here
33964 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
33966 export function AnnouncementSignatures_get_channel_id(this_ptr: bigint): number {
33967 if(!isWasmInitialized) {
33968 throw new Error("initializeWasm() must be awaited first!");
33970 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
33971 return nativeResponseValue;
33973 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33975 export function AnnouncementSignatures_set_channel_id(this_ptr: bigint, val: number): void {
33976 if(!isWasmInitialized) {
33977 throw new Error("initializeWasm() must be awaited first!");
33979 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
33980 // debug statements here
33982 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
33984 export function AnnouncementSignatures_get_short_channel_id(this_ptr: bigint): bigint {
33985 if(!isWasmInitialized) {
33986 throw new Error("initializeWasm() must be awaited first!");
33988 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
33989 return nativeResponseValue;
33991 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
33993 export function AnnouncementSignatures_set_short_channel_id(this_ptr: bigint, val: bigint): void {
33994 if(!isWasmInitialized) {
33995 throw new Error("initializeWasm() must be awaited first!");
33997 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
33998 // debug statements here
34000 // struct LDKECDSASignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
34002 export function AnnouncementSignatures_get_node_signature(this_ptr: bigint): number {
34003 if(!isWasmInitialized) {
34004 throw new Error("initializeWasm() must be awaited first!");
34006 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
34007 return nativeResponseValue;
34009 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34011 export function AnnouncementSignatures_set_node_signature(this_ptr: bigint, val: number): void {
34012 if(!isWasmInitialized) {
34013 throw new Error("initializeWasm() must be awaited first!");
34015 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
34016 // debug statements here
34018 // struct LDKECDSASignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
34020 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: bigint): number {
34021 if(!isWasmInitialized) {
34022 throw new Error("initializeWasm() must be awaited first!");
34024 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
34025 return nativeResponseValue;
34027 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34029 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: bigint, val: number): void {
34030 if(!isWasmInitialized) {
34031 throw new Error("initializeWasm() must be awaited first!");
34033 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
34034 // debug statements here
34036 // MUST_USE_RES struct LDKAnnouncementSignatures AnnouncementSignatures_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t short_channel_id_arg, struct LDKECDSASignature node_signature_arg, struct LDKECDSASignature bitcoin_signature_arg);
34038 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): bigint {
34039 if(!isWasmInitialized) {
34040 throw new Error("initializeWasm() must be awaited first!");
34042 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
34043 return nativeResponseValue;
34045 // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
34047 export function AnnouncementSignatures_clone_ptr(arg: bigint): bigint {
34048 if(!isWasmInitialized) {
34049 throw new Error("initializeWasm() must be awaited first!");
34051 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
34052 return nativeResponseValue;
34054 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
34056 export function AnnouncementSignatures_clone(orig: bigint): bigint {
34057 if(!isWasmInitialized) {
34058 throw new Error("initializeWasm() must be awaited first!");
34060 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
34061 return nativeResponseValue;
34063 // bool AnnouncementSignatures_eq(const struct LDKAnnouncementSignatures *NONNULL_PTR a, const struct LDKAnnouncementSignatures *NONNULL_PTR b);
34065 export function AnnouncementSignatures_eq(a: bigint, b: bigint): boolean {
34066 if(!isWasmInitialized) {
34067 throw new Error("initializeWasm() must be awaited first!");
34069 const nativeResponseValue = wasm.TS_AnnouncementSignatures_eq(a, b);
34070 return nativeResponseValue;
34072 // void SocketAddress_free(struct LDKSocketAddress this_ptr);
34074 export function SocketAddress_free(this_ptr: bigint): void {
34075 if(!isWasmInitialized) {
34076 throw new Error("initializeWasm() must be awaited first!");
34078 const nativeResponseValue = wasm.TS_SocketAddress_free(this_ptr);
34079 // debug statements here
34081 // uint64_t SocketAddress_clone_ptr(LDKSocketAddress *NONNULL_PTR arg);
34083 export function SocketAddress_clone_ptr(arg: bigint): bigint {
34084 if(!isWasmInitialized) {
34085 throw new Error("initializeWasm() must be awaited first!");
34087 const nativeResponseValue = wasm.TS_SocketAddress_clone_ptr(arg);
34088 return nativeResponseValue;
34090 // struct LDKSocketAddress SocketAddress_clone(const struct LDKSocketAddress *NONNULL_PTR orig);
34092 export function SocketAddress_clone(orig: bigint): bigint {
34093 if(!isWasmInitialized) {
34094 throw new Error("initializeWasm() must be awaited first!");
34096 const nativeResponseValue = wasm.TS_SocketAddress_clone(orig);
34097 return nativeResponseValue;
34099 // struct LDKSocketAddress SocketAddress_tcp_ip_v4(struct LDKFourBytes addr, uint16_t port);
34101 export function SocketAddress_tcp_ip_v4(addr: number, port: number): bigint {
34102 if(!isWasmInitialized) {
34103 throw new Error("initializeWasm() must be awaited first!");
34105 const nativeResponseValue = wasm.TS_SocketAddress_tcp_ip_v4(addr, port);
34106 return nativeResponseValue;
34108 // struct LDKSocketAddress SocketAddress_tcp_ip_v6(struct LDKSixteenBytes addr, uint16_t port);
34110 export function SocketAddress_tcp_ip_v6(addr: number, port: number): bigint {
34111 if(!isWasmInitialized) {
34112 throw new Error("initializeWasm() must be awaited first!");
34114 const nativeResponseValue = wasm.TS_SocketAddress_tcp_ip_v6(addr, port);
34115 return nativeResponseValue;
34117 // struct LDKSocketAddress SocketAddress_onion_v2(struct LDKTwelveBytes a);
34119 export function SocketAddress_onion_v2(a: number): bigint {
34120 if(!isWasmInitialized) {
34121 throw new Error("initializeWasm() must be awaited first!");
34123 const nativeResponseValue = wasm.TS_SocketAddress_onion_v2(a);
34124 return nativeResponseValue;
34126 // struct LDKSocketAddress SocketAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
34128 export function SocketAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): bigint {
34129 if(!isWasmInitialized) {
34130 throw new Error("initializeWasm() must be awaited first!");
34132 const nativeResponseValue = wasm.TS_SocketAddress_onion_v3(ed25519_pubkey, checksum, version, port);
34133 return nativeResponseValue;
34135 // struct LDKSocketAddress SocketAddress_hostname(struct LDKHostname hostname, uint16_t port);
34137 export function SocketAddress_hostname(hostname: bigint, port: number): bigint {
34138 if(!isWasmInitialized) {
34139 throw new Error("initializeWasm() must be awaited first!");
34141 const nativeResponseValue = wasm.TS_SocketAddress_hostname(hostname, port);
34142 return nativeResponseValue;
34144 // bool SocketAddress_eq(const struct LDKSocketAddress *NONNULL_PTR a, const struct LDKSocketAddress *NONNULL_PTR b);
34146 export function SocketAddress_eq(a: bigint, b: bigint): boolean {
34147 if(!isWasmInitialized) {
34148 throw new Error("initializeWasm() must be awaited first!");
34150 const nativeResponseValue = wasm.TS_SocketAddress_eq(a, b);
34151 return nativeResponseValue;
34153 // struct LDKCVec_u8Z SocketAddress_write(const struct LDKSocketAddress *NONNULL_PTR obj);
34155 export function SocketAddress_write(obj: bigint): number {
34156 if(!isWasmInitialized) {
34157 throw new Error("initializeWasm() must be awaited first!");
34159 const nativeResponseValue = wasm.TS_SocketAddress_write(obj);
34160 return nativeResponseValue;
34162 // struct LDKCResult_SocketAddressDecodeErrorZ SocketAddress_read(struct LDKu8slice ser);
34164 export function SocketAddress_read(ser: number): bigint {
34165 if(!isWasmInitialized) {
34166 throw new Error("initializeWasm() must be awaited first!");
34168 const nativeResponseValue = wasm.TS_SocketAddress_read(ser);
34169 return nativeResponseValue;
34171 // enum LDKSocketAddressParseError SocketAddressParseError_clone(const enum LDKSocketAddressParseError *NONNULL_PTR orig);
34173 export function SocketAddressParseError_clone(orig: bigint): SocketAddressParseError {
34174 if(!isWasmInitialized) {
34175 throw new Error("initializeWasm() must be awaited first!");
34177 const nativeResponseValue = wasm.TS_SocketAddressParseError_clone(orig);
34178 return nativeResponseValue;
34180 // enum LDKSocketAddressParseError SocketAddressParseError_socket_addr_parse(void);
34182 export function SocketAddressParseError_socket_addr_parse(): SocketAddressParseError {
34183 if(!isWasmInitialized) {
34184 throw new Error("initializeWasm() must be awaited first!");
34186 const nativeResponseValue = wasm.TS_SocketAddressParseError_socket_addr_parse();
34187 return nativeResponseValue;
34189 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_input(void);
34191 export function SocketAddressParseError_invalid_input(): SocketAddressParseError {
34192 if(!isWasmInitialized) {
34193 throw new Error("initializeWasm() must be awaited first!");
34195 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_input();
34196 return nativeResponseValue;
34198 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_port(void);
34200 export function SocketAddressParseError_invalid_port(): SocketAddressParseError {
34201 if(!isWasmInitialized) {
34202 throw new Error("initializeWasm() must be awaited first!");
34204 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_port();
34205 return nativeResponseValue;
34207 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_onion_v3(void);
34209 export function SocketAddressParseError_invalid_onion_v3(): SocketAddressParseError {
34210 if(!isWasmInitialized) {
34211 throw new Error("initializeWasm() must be awaited first!");
34213 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_onion_v3();
34214 return nativeResponseValue;
34216 // bool SocketAddressParseError_eq(const enum LDKSocketAddressParseError *NONNULL_PTR a, const enum LDKSocketAddressParseError *NONNULL_PTR b);
34218 export function SocketAddressParseError_eq(a: bigint, b: bigint): boolean {
34219 if(!isWasmInitialized) {
34220 throw new Error("initializeWasm() must be awaited first!");
34222 const nativeResponseValue = wasm.TS_SocketAddressParseError_eq(a, b);
34223 return nativeResponseValue;
34225 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ parse_onion_address(struct LDKStr host, uint16_t port);
34227 export function parse_onion_address(host: number, port: number): bigint {
34228 if(!isWasmInitialized) {
34229 throw new Error("initializeWasm() must be awaited first!");
34231 const nativeResponseValue = wasm.TS_parse_onion_address(host, port);
34232 return nativeResponseValue;
34234 // struct LDKStr SocketAddress_to_str(const struct LDKSocketAddress *NONNULL_PTR o);
34236 export function SocketAddress_to_str(o: bigint): number {
34237 if(!isWasmInitialized) {
34238 throw new Error("initializeWasm() must be awaited first!");
34240 const nativeResponseValue = wasm.TS_SocketAddress_to_str(o);
34241 return nativeResponseValue;
34243 // void UnsignedGossipMessage_free(struct LDKUnsignedGossipMessage this_ptr);
34245 export function UnsignedGossipMessage_free(this_ptr: bigint): void {
34246 if(!isWasmInitialized) {
34247 throw new Error("initializeWasm() must be awaited first!");
34249 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_free(this_ptr);
34250 // debug statements here
34252 // uint64_t UnsignedGossipMessage_clone_ptr(LDKUnsignedGossipMessage *NONNULL_PTR arg);
34254 export function UnsignedGossipMessage_clone_ptr(arg: bigint): bigint {
34255 if(!isWasmInitialized) {
34256 throw new Error("initializeWasm() must be awaited first!");
34258 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone_ptr(arg);
34259 return nativeResponseValue;
34261 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_clone(const struct LDKUnsignedGossipMessage *NONNULL_PTR orig);
34263 export function UnsignedGossipMessage_clone(orig: bigint): bigint {
34264 if(!isWasmInitialized) {
34265 throw new Error("initializeWasm() must be awaited first!");
34267 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone(orig);
34268 return nativeResponseValue;
34270 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_announcement(struct LDKUnsignedChannelAnnouncement a);
34272 export function UnsignedGossipMessage_channel_announcement(a: bigint): bigint {
34273 if(!isWasmInitialized) {
34274 throw new Error("initializeWasm() must be awaited first!");
34276 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_announcement(a);
34277 return nativeResponseValue;
34279 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_update(struct LDKUnsignedChannelUpdate a);
34281 export function UnsignedGossipMessage_channel_update(a: bigint): bigint {
34282 if(!isWasmInitialized) {
34283 throw new Error("initializeWasm() must be awaited first!");
34285 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_update(a);
34286 return nativeResponseValue;
34288 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_node_announcement(struct LDKUnsignedNodeAnnouncement a);
34290 export function UnsignedGossipMessage_node_announcement(a: bigint): bigint {
34291 if(!isWasmInitialized) {
34292 throw new Error("initializeWasm() must be awaited first!");
34294 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_node_announcement(a);
34295 return nativeResponseValue;
34297 // struct LDKCVec_u8Z UnsignedGossipMessage_write(const struct LDKUnsignedGossipMessage *NONNULL_PTR obj);
34299 export function UnsignedGossipMessage_write(obj: bigint): number {
34300 if(!isWasmInitialized) {
34301 throw new Error("initializeWasm() must be awaited first!");
34303 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_write(obj);
34304 return nativeResponseValue;
34306 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
34308 export function UnsignedNodeAnnouncement_free(this_obj: bigint): void {
34309 if(!isWasmInitialized) {
34310 throw new Error("initializeWasm() must be awaited first!");
34312 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
34313 // debug statements here
34315 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
34317 export function UnsignedNodeAnnouncement_get_features(this_ptr: bigint): bigint {
34318 if(!isWasmInitialized) {
34319 throw new Error("initializeWasm() must be awaited first!");
34321 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
34322 return nativeResponseValue;
34324 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
34326 export function UnsignedNodeAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
34327 if(!isWasmInitialized) {
34328 throw new Error("initializeWasm() must be awaited first!");
34330 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
34331 // debug statements here
34333 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
34335 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: bigint): number {
34336 if(!isWasmInitialized) {
34337 throw new Error("initializeWasm() must be awaited first!");
34339 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
34340 return nativeResponseValue;
34342 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
34344 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: bigint, val: number): void {
34345 if(!isWasmInitialized) {
34346 throw new Error("initializeWasm() must be awaited first!");
34348 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
34349 // debug statements here
34351 // struct LDKNodeId UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
34353 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: bigint): bigint {
34354 if(!isWasmInitialized) {
34355 throw new Error("initializeWasm() must be awaited first!");
34357 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
34358 return nativeResponseValue;
34360 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
34362 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: bigint, val: bigint): void {
34363 if(!isWasmInitialized) {
34364 throw new Error("initializeWasm() must be awaited first!");
34366 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
34367 // debug statements here
34369 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
34371 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: bigint): number {
34372 if(!isWasmInitialized) {
34373 throw new Error("initializeWasm() must be awaited first!");
34375 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
34376 return nativeResponseValue;
34378 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
34380 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: bigint, val: number): void {
34381 if(!isWasmInitialized) {
34382 throw new Error("initializeWasm() must be awaited first!");
34384 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
34385 // debug statements here
34387 // struct LDKNodeAlias UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
34389 export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): bigint {
34390 if(!isWasmInitialized) {
34391 throw new Error("initializeWasm() must be awaited first!");
34393 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
34394 return nativeResponseValue;
34396 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
34398 export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: bigint): void {
34399 if(!isWasmInitialized) {
34400 throw new Error("initializeWasm() must be awaited first!");
34402 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
34403 // debug statements here
34405 // struct LDKCVec_SocketAddressZ UnsignedNodeAnnouncement_get_addresses(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
34407 export function UnsignedNodeAnnouncement_get_addresses(this_ptr: bigint): number {
34408 if(!isWasmInitialized) {
34409 throw new Error("initializeWasm() must be awaited first!");
34411 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_addresses(this_ptr);
34412 return nativeResponseValue;
34414 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_SocketAddressZ val);
34416 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: bigint, val: number): void {
34417 if(!isWasmInitialized) {
34418 throw new Error("initializeWasm() must be awaited first!");
34420 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
34421 // debug statements here
34423 // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
34425 export function UnsignedNodeAnnouncement_clone_ptr(arg: bigint): bigint {
34426 if(!isWasmInitialized) {
34427 throw new Error("initializeWasm() must be awaited first!");
34429 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
34430 return nativeResponseValue;
34432 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
34434 export function UnsignedNodeAnnouncement_clone(orig: bigint): bigint {
34435 if(!isWasmInitialized) {
34436 throw new Error("initializeWasm() must be awaited first!");
34438 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
34439 return nativeResponseValue;
34441 // bool UnsignedNodeAnnouncement_eq(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR a, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR b);
34443 export function UnsignedNodeAnnouncement_eq(a: bigint, b: bigint): boolean {
34444 if(!isWasmInitialized) {
34445 throw new Error("initializeWasm() must be awaited first!");
34447 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_eq(a, b);
34448 return nativeResponseValue;
34450 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
34452 export function NodeAnnouncement_free(this_obj: bigint): void {
34453 if(!isWasmInitialized) {
34454 throw new Error("initializeWasm() must be awaited first!");
34456 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
34457 // debug statements here
34459 // struct LDKECDSASignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
34461 export function NodeAnnouncement_get_signature(this_ptr: bigint): number {
34462 if(!isWasmInitialized) {
34463 throw new Error("initializeWasm() must be awaited first!");
34465 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
34466 return nativeResponseValue;
34468 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34470 export function NodeAnnouncement_set_signature(this_ptr: bigint, val: number): void {
34471 if(!isWasmInitialized) {
34472 throw new Error("initializeWasm() must be awaited first!");
34474 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
34475 // debug statements here
34477 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
34479 export function NodeAnnouncement_get_contents(this_ptr: bigint): bigint {
34480 if(!isWasmInitialized) {
34481 throw new Error("initializeWasm() must be awaited first!");
34483 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
34484 return nativeResponseValue;
34486 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
34488 export function NodeAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
34489 if(!isWasmInitialized) {
34490 throw new Error("initializeWasm() must be awaited first!");
34492 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
34493 // debug statements here
34495 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKECDSASignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
34497 export function NodeAnnouncement_new(signature_arg: number, contents_arg: bigint): bigint {
34498 if(!isWasmInitialized) {
34499 throw new Error("initializeWasm() must be awaited first!");
34501 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
34502 return nativeResponseValue;
34504 // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
34506 export function NodeAnnouncement_clone_ptr(arg: bigint): bigint {
34507 if(!isWasmInitialized) {
34508 throw new Error("initializeWasm() must be awaited first!");
34510 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
34511 return nativeResponseValue;
34513 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
34515 export function NodeAnnouncement_clone(orig: bigint): bigint {
34516 if(!isWasmInitialized) {
34517 throw new Error("initializeWasm() must be awaited first!");
34519 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
34520 return nativeResponseValue;
34522 // bool NodeAnnouncement_eq(const struct LDKNodeAnnouncement *NONNULL_PTR a, const struct LDKNodeAnnouncement *NONNULL_PTR b);
34524 export function NodeAnnouncement_eq(a: bigint, b: bigint): boolean {
34525 if(!isWasmInitialized) {
34526 throw new Error("initializeWasm() must be awaited first!");
34528 const nativeResponseValue = wasm.TS_NodeAnnouncement_eq(a, b);
34529 return nativeResponseValue;
34531 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
34533 export function UnsignedChannelAnnouncement_free(this_obj: bigint): void {
34534 if(!isWasmInitialized) {
34535 throw new Error("initializeWasm() must be awaited first!");
34537 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
34538 // debug statements here
34540 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34542 export function UnsignedChannelAnnouncement_get_features(this_ptr: bigint): bigint {
34543 if(!isWasmInitialized) {
34544 throw new Error("initializeWasm() must be awaited first!");
34546 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
34547 return nativeResponseValue;
34549 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
34551 export function UnsignedChannelAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
34552 if(!isWasmInitialized) {
34553 throw new Error("initializeWasm() must be awaited first!");
34555 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
34556 // debug statements here
34558 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
34560 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: bigint): number {
34561 if(!isWasmInitialized) {
34562 throw new Error("initializeWasm() must be awaited first!");
34564 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
34565 return nativeResponseValue;
34567 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34569 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: bigint, val: number): void {
34570 if(!isWasmInitialized) {
34571 throw new Error("initializeWasm() must be awaited first!");
34573 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
34574 // debug statements here
34576 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34578 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: bigint): bigint {
34579 if(!isWasmInitialized) {
34580 throw new Error("initializeWasm() must be awaited first!");
34582 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
34583 return nativeResponseValue;
34585 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
34587 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: bigint, val: bigint): void {
34588 if(!isWasmInitialized) {
34589 throw new Error("initializeWasm() must be awaited first!");
34591 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
34592 // debug statements here
34594 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34596 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: bigint): bigint {
34597 if(!isWasmInitialized) {
34598 throw new Error("initializeWasm() must be awaited first!");
34600 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
34601 return nativeResponseValue;
34603 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
34605 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: bigint, val: bigint): void {
34606 if(!isWasmInitialized) {
34607 throw new Error("initializeWasm() must be awaited first!");
34609 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
34610 // debug statements here
34612 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34614 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: bigint): bigint {
34615 if(!isWasmInitialized) {
34616 throw new Error("initializeWasm() must be awaited first!");
34618 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
34619 return nativeResponseValue;
34621 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
34623 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: bigint, val: bigint): void {
34624 if(!isWasmInitialized) {
34625 throw new Error("initializeWasm() must be awaited first!");
34627 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
34628 // debug statements here
34630 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34632 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: bigint): bigint {
34633 if(!isWasmInitialized) {
34634 throw new Error("initializeWasm() must be awaited first!");
34636 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
34637 return nativeResponseValue;
34639 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
34641 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: bigint, val: bigint): void {
34642 if(!isWasmInitialized) {
34643 throw new Error("initializeWasm() must be awaited first!");
34645 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
34646 // debug statements here
34648 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34650 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: bigint): bigint {
34651 if(!isWasmInitialized) {
34652 throw new Error("initializeWasm() must be awaited first!");
34654 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
34655 return nativeResponseValue;
34657 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
34659 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: bigint, val: bigint): void {
34660 if(!isWasmInitialized) {
34661 throw new Error("initializeWasm() must be awaited first!");
34663 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
34664 // debug statements here
34666 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_get_excess_data(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
34668 export function UnsignedChannelAnnouncement_get_excess_data(this_ptr: bigint): number {
34669 if(!isWasmInitialized) {
34670 throw new Error("initializeWasm() must be awaited first!");
34672 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_excess_data(this_ptr);
34673 return nativeResponseValue;
34675 // void UnsignedChannelAnnouncement_set_excess_data(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
34677 export function UnsignedChannelAnnouncement_set_excess_data(this_ptr: bigint, val: number): void {
34678 if(!isWasmInitialized) {
34679 throw new Error("initializeWasm() must be awaited first!");
34681 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_excess_data(this_ptr, val);
34682 // debug statements here
34684 // 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);
34686 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 {
34687 if(!isWasmInitialized) {
34688 throw new Error("initializeWasm() must be awaited first!");
34690 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);
34691 return nativeResponseValue;
34693 // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
34695 export function UnsignedChannelAnnouncement_clone_ptr(arg: bigint): bigint {
34696 if(!isWasmInitialized) {
34697 throw new Error("initializeWasm() must be awaited first!");
34699 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
34700 return nativeResponseValue;
34702 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
34704 export function UnsignedChannelAnnouncement_clone(orig: bigint): bigint {
34705 if(!isWasmInitialized) {
34706 throw new Error("initializeWasm() must be awaited first!");
34708 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
34709 return nativeResponseValue;
34711 // bool UnsignedChannelAnnouncement_eq(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR a, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR b);
34713 export function UnsignedChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
34714 if(!isWasmInitialized) {
34715 throw new Error("initializeWasm() must be awaited first!");
34717 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_eq(a, b);
34718 return nativeResponseValue;
34720 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
34722 export function ChannelAnnouncement_free(this_obj: bigint): void {
34723 if(!isWasmInitialized) {
34724 throw new Error("initializeWasm() must be awaited first!");
34726 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
34727 // debug statements here
34729 // struct LDKECDSASignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
34731 export function ChannelAnnouncement_get_node_signature_1(this_ptr: bigint): number {
34732 if(!isWasmInitialized) {
34733 throw new Error("initializeWasm() must be awaited first!");
34735 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
34736 return nativeResponseValue;
34738 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34740 export function ChannelAnnouncement_set_node_signature_1(this_ptr: bigint, val: number): void {
34741 if(!isWasmInitialized) {
34742 throw new Error("initializeWasm() must be awaited first!");
34744 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
34745 // debug statements here
34747 // struct LDKECDSASignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
34749 export function ChannelAnnouncement_get_node_signature_2(this_ptr: bigint): number {
34750 if(!isWasmInitialized) {
34751 throw new Error("initializeWasm() must be awaited first!");
34753 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
34754 return nativeResponseValue;
34756 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34758 export function ChannelAnnouncement_set_node_signature_2(this_ptr: bigint, val: number): void {
34759 if(!isWasmInitialized) {
34760 throw new Error("initializeWasm() must be awaited first!");
34762 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
34763 // debug statements here
34765 // struct LDKECDSASignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
34767 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: bigint): number {
34768 if(!isWasmInitialized) {
34769 throw new Error("initializeWasm() must be awaited first!");
34771 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
34772 return nativeResponseValue;
34774 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34776 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: bigint, val: number): void {
34777 if(!isWasmInitialized) {
34778 throw new Error("initializeWasm() must be awaited first!");
34780 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
34781 // debug statements here
34783 // struct LDKECDSASignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
34785 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: bigint): number {
34786 if(!isWasmInitialized) {
34787 throw new Error("initializeWasm() must be awaited first!");
34789 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
34790 return nativeResponseValue;
34792 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34794 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: bigint, val: number): void {
34795 if(!isWasmInitialized) {
34796 throw new Error("initializeWasm() must be awaited first!");
34798 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
34799 // debug statements here
34801 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
34803 export function ChannelAnnouncement_get_contents(this_ptr: bigint): bigint {
34804 if(!isWasmInitialized) {
34805 throw new Error("initializeWasm() must be awaited first!");
34807 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
34808 return nativeResponseValue;
34810 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
34812 export function ChannelAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
34813 if(!isWasmInitialized) {
34814 throw new Error("initializeWasm() must be awaited first!");
34816 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
34817 // debug statements here
34819 // 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);
34821 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 {
34822 if(!isWasmInitialized) {
34823 throw new Error("initializeWasm() must be awaited first!");
34825 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
34826 return nativeResponseValue;
34828 // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
34830 export function ChannelAnnouncement_clone_ptr(arg: bigint): bigint {
34831 if(!isWasmInitialized) {
34832 throw new Error("initializeWasm() must be awaited first!");
34834 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
34835 return nativeResponseValue;
34837 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
34839 export function ChannelAnnouncement_clone(orig: bigint): bigint {
34840 if(!isWasmInitialized) {
34841 throw new Error("initializeWasm() must be awaited first!");
34843 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
34844 return nativeResponseValue;
34846 // bool ChannelAnnouncement_eq(const struct LDKChannelAnnouncement *NONNULL_PTR a, const struct LDKChannelAnnouncement *NONNULL_PTR b);
34848 export function ChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
34849 if(!isWasmInitialized) {
34850 throw new Error("initializeWasm() must be awaited first!");
34852 const nativeResponseValue = wasm.TS_ChannelAnnouncement_eq(a, b);
34853 return nativeResponseValue;
34855 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
34857 export function UnsignedChannelUpdate_free(this_obj: bigint): void {
34858 if(!isWasmInitialized) {
34859 throw new Error("initializeWasm() must be awaited first!");
34861 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
34862 // debug statements here
34864 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
34866 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: bigint): number {
34867 if(!isWasmInitialized) {
34868 throw new Error("initializeWasm() must be awaited first!");
34870 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
34871 return nativeResponseValue;
34873 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34875 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: bigint, val: number): void {
34876 if(!isWasmInitialized) {
34877 throw new Error("initializeWasm() must be awaited first!");
34879 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
34880 // debug statements here
34882 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34884 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: bigint): bigint {
34885 if(!isWasmInitialized) {
34886 throw new Error("initializeWasm() must be awaited first!");
34888 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
34889 return nativeResponseValue;
34891 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
34893 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
34894 if(!isWasmInitialized) {
34895 throw new Error("initializeWasm() must be awaited first!");
34897 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
34898 // debug statements here
34900 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34902 export function UnsignedChannelUpdate_get_timestamp(this_ptr: bigint): number {
34903 if(!isWasmInitialized) {
34904 throw new Error("initializeWasm() must be awaited first!");
34906 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
34907 return nativeResponseValue;
34909 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
34911 export function UnsignedChannelUpdate_set_timestamp(this_ptr: bigint, val: number): void {
34912 if(!isWasmInitialized) {
34913 throw new Error("initializeWasm() must be awaited first!");
34915 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
34916 // debug statements here
34918 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34920 export function UnsignedChannelUpdate_get_flags(this_ptr: bigint): number {
34921 if(!isWasmInitialized) {
34922 throw new Error("initializeWasm() must be awaited first!");
34924 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
34925 return nativeResponseValue;
34927 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
34929 export function UnsignedChannelUpdate_set_flags(this_ptr: bigint, val: number): void {
34930 if(!isWasmInitialized) {
34931 throw new Error("initializeWasm() must be awaited first!");
34933 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
34934 // debug statements here
34936 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34938 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: bigint): number {
34939 if(!isWasmInitialized) {
34940 throw new Error("initializeWasm() must be awaited first!");
34942 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
34943 return nativeResponseValue;
34945 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
34947 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
34948 if(!isWasmInitialized) {
34949 throw new Error("initializeWasm() must be awaited first!");
34951 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
34952 // debug statements here
34954 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34956 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: bigint): bigint {
34957 if(!isWasmInitialized) {
34958 throw new Error("initializeWasm() must be awaited first!");
34960 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
34961 return nativeResponseValue;
34963 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
34965 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
34966 if(!isWasmInitialized) {
34967 throw new Error("initializeWasm() must be awaited first!");
34969 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
34970 // debug statements here
34972 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34974 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: bigint): bigint {
34975 if(!isWasmInitialized) {
34976 throw new Error("initializeWasm() must be awaited first!");
34978 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
34979 return nativeResponseValue;
34981 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
34983 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
34984 if(!isWasmInitialized) {
34985 throw new Error("initializeWasm() must be awaited first!");
34987 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
34988 // debug statements here
34990 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
34992 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: bigint): number {
34993 if(!isWasmInitialized) {
34994 throw new Error("initializeWasm() must be awaited first!");
34996 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
34997 return nativeResponseValue;
34999 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
35001 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: bigint, val: number): void {
35002 if(!isWasmInitialized) {
35003 throw new Error("initializeWasm() must be awaited first!");
35005 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
35006 // debug statements here
35008 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
35010 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: bigint): number {
35011 if(!isWasmInitialized) {
35012 throw new Error("initializeWasm() must be awaited first!");
35014 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
35015 return nativeResponseValue;
35017 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
35019 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
35020 if(!isWasmInitialized) {
35021 throw new Error("initializeWasm() must be awaited first!");
35023 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
35024 // debug statements here
35026 // struct LDKCVec_u8Z UnsignedChannelUpdate_get_excess_data(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
35028 export function UnsignedChannelUpdate_get_excess_data(this_ptr: bigint): number {
35029 if(!isWasmInitialized) {
35030 throw new Error("initializeWasm() must be awaited first!");
35032 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_excess_data(this_ptr);
35033 return nativeResponseValue;
35035 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
35037 export function UnsignedChannelUpdate_set_excess_data(this_ptr: bigint, val: number): void {
35038 if(!isWasmInitialized) {
35039 throw new Error("initializeWasm() must be awaited first!");
35041 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
35042 // debug statements here
35044 // 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);
35046 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 {
35047 if(!isWasmInitialized) {
35048 throw new Error("initializeWasm() must be awaited first!");
35050 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);
35051 return nativeResponseValue;
35053 // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
35055 export function UnsignedChannelUpdate_clone_ptr(arg: bigint): bigint {
35056 if(!isWasmInitialized) {
35057 throw new Error("initializeWasm() must be awaited first!");
35059 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
35060 return nativeResponseValue;
35062 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
35064 export function UnsignedChannelUpdate_clone(orig: bigint): bigint {
35065 if(!isWasmInitialized) {
35066 throw new Error("initializeWasm() must be awaited first!");
35068 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
35069 return nativeResponseValue;
35071 // bool UnsignedChannelUpdate_eq(const struct LDKUnsignedChannelUpdate *NONNULL_PTR a, const struct LDKUnsignedChannelUpdate *NONNULL_PTR b);
35073 export function UnsignedChannelUpdate_eq(a: bigint, b: bigint): boolean {
35074 if(!isWasmInitialized) {
35075 throw new Error("initializeWasm() must be awaited first!");
35077 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_eq(a, b);
35078 return nativeResponseValue;
35080 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
35082 export function ChannelUpdate_free(this_obj: bigint): void {
35083 if(!isWasmInitialized) {
35084 throw new Error("initializeWasm() must be awaited first!");
35086 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
35087 // debug statements here
35089 // struct LDKECDSASignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
35091 export function ChannelUpdate_get_signature(this_ptr: bigint): number {
35092 if(!isWasmInitialized) {
35093 throw new Error("initializeWasm() must be awaited first!");
35095 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
35096 return nativeResponseValue;
35098 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
35100 export function ChannelUpdate_set_signature(this_ptr: bigint, val: number): void {
35101 if(!isWasmInitialized) {
35102 throw new Error("initializeWasm() must be awaited first!");
35104 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
35105 // debug statements here
35107 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
35109 export function ChannelUpdate_get_contents(this_ptr: bigint): bigint {
35110 if(!isWasmInitialized) {
35111 throw new Error("initializeWasm() must be awaited first!");
35113 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
35114 return nativeResponseValue;
35116 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
35118 export function ChannelUpdate_set_contents(this_ptr: bigint, val: bigint): void {
35119 if(!isWasmInitialized) {
35120 throw new Error("initializeWasm() must be awaited first!");
35122 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
35123 // debug statements here
35125 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKECDSASignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
35127 export function ChannelUpdate_new(signature_arg: number, contents_arg: bigint): bigint {
35128 if(!isWasmInitialized) {
35129 throw new Error("initializeWasm() must be awaited first!");
35131 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
35132 return nativeResponseValue;
35134 // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
35136 export function ChannelUpdate_clone_ptr(arg: bigint): bigint {
35137 if(!isWasmInitialized) {
35138 throw new Error("initializeWasm() must be awaited first!");
35140 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
35141 return nativeResponseValue;
35143 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
35145 export function ChannelUpdate_clone(orig: bigint): bigint {
35146 if(!isWasmInitialized) {
35147 throw new Error("initializeWasm() must be awaited first!");
35149 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
35150 return nativeResponseValue;
35152 // bool ChannelUpdate_eq(const struct LDKChannelUpdate *NONNULL_PTR a, const struct LDKChannelUpdate *NONNULL_PTR b);
35154 export function ChannelUpdate_eq(a: bigint, b: bigint): boolean {
35155 if(!isWasmInitialized) {
35156 throw new Error("initializeWasm() must be awaited first!");
35158 const nativeResponseValue = wasm.TS_ChannelUpdate_eq(a, b);
35159 return nativeResponseValue;
35161 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
35163 export function QueryChannelRange_free(this_obj: bigint): void {
35164 if(!isWasmInitialized) {
35165 throw new Error("initializeWasm() must be awaited first!");
35167 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
35168 // debug statements here
35170 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
35172 export function QueryChannelRange_get_chain_hash(this_ptr: bigint): number {
35173 if(!isWasmInitialized) {
35174 throw new Error("initializeWasm() must be awaited first!");
35176 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
35177 return nativeResponseValue;
35179 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35181 export function QueryChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
35182 if(!isWasmInitialized) {
35183 throw new Error("initializeWasm() must be awaited first!");
35185 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
35186 // debug statements here
35188 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
35190 export function QueryChannelRange_get_first_blocknum(this_ptr: bigint): number {
35191 if(!isWasmInitialized) {
35192 throw new Error("initializeWasm() must be awaited first!");
35194 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
35195 return nativeResponseValue;
35197 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
35199 export function QueryChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
35200 if(!isWasmInitialized) {
35201 throw new Error("initializeWasm() must be awaited first!");
35203 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
35204 // debug statements here
35206 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
35208 export function QueryChannelRange_get_number_of_blocks(this_ptr: bigint): number {
35209 if(!isWasmInitialized) {
35210 throw new Error("initializeWasm() must be awaited first!");
35212 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
35213 return nativeResponseValue;
35215 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
35217 export function QueryChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
35218 if(!isWasmInitialized) {
35219 throw new Error("initializeWasm() must be awaited first!");
35221 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
35222 // debug statements here
35224 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
35226 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): bigint {
35227 if(!isWasmInitialized) {
35228 throw new Error("initializeWasm() must be awaited first!");
35230 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
35231 return nativeResponseValue;
35233 // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
35235 export function QueryChannelRange_clone_ptr(arg: bigint): bigint {
35236 if(!isWasmInitialized) {
35237 throw new Error("initializeWasm() must be awaited first!");
35239 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
35240 return nativeResponseValue;
35242 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
35244 export function QueryChannelRange_clone(orig: bigint): bigint {
35245 if(!isWasmInitialized) {
35246 throw new Error("initializeWasm() must be awaited first!");
35248 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
35249 return nativeResponseValue;
35251 // bool QueryChannelRange_eq(const struct LDKQueryChannelRange *NONNULL_PTR a, const struct LDKQueryChannelRange *NONNULL_PTR b);
35253 export function QueryChannelRange_eq(a: bigint, b: bigint): boolean {
35254 if(!isWasmInitialized) {
35255 throw new Error("initializeWasm() must be awaited first!");
35257 const nativeResponseValue = wasm.TS_QueryChannelRange_eq(a, b);
35258 return nativeResponseValue;
35260 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
35262 export function ReplyChannelRange_free(this_obj: bigint): void {
35263 if(!isWasmInitialized) {
35264 throw new Error("initializeWasm() must be awaited first!");
35266 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
35267 // debug statements here
35269 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
35271 export function ReplyChannelRange_get_chain_hash(this_ptr: bigint): number {
35272 if(!isWasmInitialized) {
35273 throw new Error("initializeWasm() must be awaited first!");
35275 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
35276 return nativeResponseValue;
35278 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35280 export function ReplyChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
35281 if(!isWasmInitialized) {
35282 throw new Error("initializeWasm() must be awaited first!");
35284 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
35285 // debug statements here
35287 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
35289 export function ReplyChannelRange_get_first_blocknum(this_ptr: bigint): number {
35290 if(!isWasmInitialized) {
35291 throw new Error("initializeWasm() must be awaited first!");
35293 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
35294 return nativeResponseValue;
35296 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
35298 export function ReplyChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
35299 if(!isWasmInitialized) {
35300 throw new Error("initializeWasm() must be awaited first!");
35302 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
35303 // debug statements here
35305 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
35307 export function ReplyChannelRange_get_number_of_blocks(this_ptr: bigint): number {
35308 if(!isWasmInitialized) {
35309 throw new Error("initializeWasm() must be awaited first!");
35311 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
35312 return nativeResponseValue;
35314 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
35316 export function ReplyChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
35317 if(!isWasmInitialized) {
35318 throw new Error("initializeWasm() must be awaited first!");
35320 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
35321 // debug statements here
35323 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
35325 export function ReplyChannelRange_get_sync_complete(this_ptr: bigint): boolean {
35326 if(!isWasmInitialized) {
35327 throw new Error("initializeWasm() must be awaited first!");
35329 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
35330 return nativeResponseValue;
35332 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
35334 export function ReplyChannelRange_set_sync_complete(this_ptr: bigint, val: boolean): void {
35335 if(!isWasmInitialized) {
35336 throw new Error("initializeWasm() must be awaited first!");
35338 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
35339 // debug statements here
35341 // struct LDKCVec_u64Z ReplyChannelRange_get_short_channel_ids(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
35343 export function ReplyChannelRange_get_short_channel_ids(this_ptr: bigint): number {
35344 if(!isWasmInitialized) {
35345 throw new Error("initializeWasm() must be awaited first!");
35347 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_short_channel_ids(this_ptr);
35348 return nativeResponseValue;
35350 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
35352 export function ReplyChannelRange_set_short_channel_ids(this_ptr: bigint, val: number): void {
35353 if(!isWasmInitialized) {
35354 throw new Error("initializeWasm() must be awaited first!");
35356 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
35357 // debug statements here
35359 // 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);
35361 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 {
35362 if(!isWasmInitialized) {
35363 throw new Error("initializeWasm() must be awaited first!");
35365 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
35366 return nativeResponseValue;
35368 // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
35370 export function ReplyChannelRange_clone_ptr(arg: bigint): bigint {
35371 if(!isWasmInitialized) {
35372 throw new Error("initializeWasm() must be awaited first!");
35374 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
35375 return nativeResponseValue;
35377 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
35379 export function ReplyChannelRange_clone(orig: bigint): bigint {
35380 if(!isWasmInitialized) {
35381 throw new Error("initializeWasm() must be awaited first!");
35383 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
35384 return nativeResponseValue;
35386 // bool ReplyChannelRange_eq(const struct LDKReplyChannelRange *NONNULL_PTR a, const struct LDKReplyChannelRange *NONNULL_PTR b);
35388 export function ReplyChannelRange_eq(a: bigint, b: bigint): boolean {
35389 if(!isWasmInitialized) {
35390 throw new Error("initializeWasm() must be awaited first!");
35392 const nativeResponseValue = wasm.TS_ReplyChannelRange_eq(a, b);
35393 return nativeResponseValue;
35395 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
35397 export function QueryShortChannelIds_free(this_obj: bigint): void {
35398 if(!isWasmInitialized) {
35399 throw new Error("initializeWasm() must be awaited first!");
35401 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
35402 // debug statements here
35404 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
35406 export function QueryShortChannelIds_get_chain_hash(this_ptr: bigint): number {
35407 if(!isWasmInitialized) {
35408 throw new Error("initializeWasm() must be awaited first!");
35410 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
35411 return nativeResponseValue;
35413 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35415 export function QueryShortChannelIds_set_chain_hash(this_ptr: bigint, val: number): void {
35416 if(!isWasmInitialized) {
35417 throw new Error("initializeWasm() must be awaited first!");
35419 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
35420 // debug statements here
35422 // struct LDKCVec_u64Z QueryShortChannelIds_get_short_channel_ids(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr);
35424 export function QueryShortChannelIds_get_short_channel_ids(this_ptr: bigint): number {
35425 if(!isWasmInitialized) {
35426 throw new Error("initializeWasm() must be awaited first!");
35428 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_short_channel_ids(this_ptr);
35429 return nativeResponseValue;
35431 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
35433 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: bigint, val: number): void {
35434 if(!isWasmInitialized) {
35435 throw new Error("initializeWasm() must be awaited first!");
35437 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
35438 // debug statements here
35440 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
35442 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): bigint {
35443 if(!isWasmInitialized) {
35444 throw new Error("initializeWasm() must be awaited first!");
35446 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
35447 return nativeResponseValue;
35449 // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
35451 export function QueryShortChannelIds_clone_ptr(arg: bigint): bigint {
35452 if(!isWasmInitialized) {
35453 throw new Error("initializeWasm() must be awaited first!");
35455 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
35456 return nativeResponseValue;
35458 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
35460 export function QueryShortChannelIds_clone(orig: bigint): bigint {
35461 if(!isWasmInitialized) {
35462 throw new Error("initializeWasm() must be awaited first!");
35464 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
35465 return nativeResponseValue;
35467 // bool QueryShortChannelIds_eq(const struct LDKQueryShortChannelIds *NONNULL_PTR a, const struct LDKQueryShortChannelIds *NONNULL_PTR b);
35469 export function QueryShortChannelIds_eq(a: bigint, b: bigint): boolean {
35470 if(!isWasmInitialized) {
35471 throw new Error("initializeWasm() must be awaited first!");
35473 const nativeResponseValue = wasm.TS_QueryShortChannelIds_eq(a, b);
35474 return nativeResponseValue;
35476 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
35478 export function ReplyShortChannelIdsEnd_free(this_obj: bigint): void {
35479 if(!isWasmInitialized) {
35480 throw new Error("initializeWasm() must be awaited first!");
35482 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
35483 // debug statements here
35485 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
35487 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: bigint): number {
35488 if(!isWasmInitialized) {
35489 throw new Error("initializeWasm() must be awaited first!");
35491 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
35492 return nativeResponseValue;
35494 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35496 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: bigint, val: number): void {
35497 if(!isWasmInitialized) {
35498 throw new Error("initializeWasm() must be awaited first!");
35500 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
35501 // debug statements here
35503 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
35505 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: bigint): boolean {
35506 if(!isWasmInitialized) {
35507 throw new Error("initializeWasm() must be awaited first!");
35509 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
35510 return nativeResponseValue;
35512 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
35514 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: bigint, val: boolean): void {
35515 if(!isWasmInitialized) {
35516 throw new Error("initializeWasm() must be awaited first!");
35518 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
35519 // debug statements here
35521 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
35523 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): bigint {
35524 if(!isWasmInitialized) {
35525 throw new Error("initializeWasm() must be awaited first!");
35527 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
35528 return nativeResponseValue;
35530 // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
35532 export function ReplyShortChannelIdsEnd_clone_ptr(arg: bigint): bigint {
35533 if(!isWasmInitialized) {
35534 throw new Error("initializeWasm() must be awaited first!");
35536 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
35537 return nativeResponseValue;
35539 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
35541 export function ReplyShortChannelIdsEnd_clone(orig: bigint): bigint {
35542 if(!isWasmInitialized) {
35543 throw new Error("initializeWasm() must be awaited first!");
35545 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
35546 return nativeResponseValue;
35548 // bool ReplyShortChannelIdsEnd_eq(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR a, const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR b);
35550 export function ReplyShortChannelIdsEnd_eq(a: bigint, b: bigint): boolean {
35551 if(!isWasmInitialized) {
35552 throw new Error("initializeWasm() must be awaited first!");
35554 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_eq(a, b);
35555 return nativeResponseValue;
35557 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
35559 export function GossipTimestampFilter_free(this_obj: bigint): void {
35560 if(!isWasmInitialized) {
35561 throw new Error("initializeWasm() must be awaited first!");
35563 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
35564 // debug statements here
35566 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
35568 export function GossipTimestampFilter_get_chain_hash(this_ptr: bigint): number {
35569 if(!isWasmInitialized) {
35570 throw new Error("initializeWasm() must be awaited first!");
35572 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
35573 return nativeResponseValue;
35575 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35577 export function GossipTimestampFilter_set_chain_hash(this_ptr: bigint, val: number): void {
35578 if(!isWasmInitialized) {
35579 throw new Error("initializeWasm() must be awaited first!");
35581 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
35582 // debug statements here
35584 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
35586 export function GossipTimestampFilter_get_first_timestamp(this_ptr: bigint): number {
35587 if(!isWasmInitialized) {
35588 throw new Error("initializeWasm() must be awaited first!");
35590 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
35591 return nativeResponseValue;
35593 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
35595 export function GossipTimestampFilter_set_first_timestamp(this_ptr: bigint, val: number): void {
35596 if(!isWasmInitialized) {
35597 throw new Error("initializeWasm() must be awaited first!");
35599 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
35600 // debug statements here
35602 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
35604 export function GossipTimestampFilter_get_timestamp_range(this_ptr: bigint): number {
35605 if(!isWasmInitialized) {
35606 throw new Error("initializeWasm() must be awaited first!");
35608 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
35609 return nativeResponseValue;
35611 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
35613 export function GossipTimestampFilter_set_timestamp_range(this_ptr: bigint, val: number): void {
35614 if(!isWasmInitialized) {
35615 throw new Error("initializeWasm() must be awaited first!");
35617 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
35618 // debug statements here
35620 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
35622 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): bigint {
35623 if(!isWasmInitialized) {
35624 throw new Error("initializeWasm() must be awaited first!");
35626 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
35627 return nativeResponseValue;
35629 // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
35631 export function GossipTimestampFilter_clone_ptr(arg: bigint): bigint {
35632 if(!isWasmInitialized) {
35633 throw new Error("initializeWasm() must be awaited first!");
35635 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
35636 return nativeResponseValue;
35638 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
35640 export function GossipTimestampFilter_clone(orig: bigint): bigint {
35641 if(!isWasmInitialized) {
35642 throw new Error("initializeWasm() must be awaited first!");
35644 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
35645 return nativeResponseValue;
35647 // bool GossipTimestampFilter_eq(const struct LDKGossipTimestampFilter *NONNULL_PTR a, const struct LDKGossipTimestampFilter *NONNULL_PTR b);
35649 export function GossipTimestampFilter_eq(a: bigint, b: bigint): boolean {
35650 if(!isWasmInitialized) {
35651 throw new Error("initializeWasm() must be awaited first!");
35653 const nativeResponseValue = wasm.TS_GossipTimestampFilter_eq(a, b);
35654 return nativeResponseValue;
35656 // void ErrorAction_free(struct LDKErrorAction this_ptr);
35658 export function ErrorAction_free(this_ptr: bigint): void {
35659 if(!isWasmInitialized) {
35660 throw new Error("initializeWasm() must be awaited first!");
35662 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
35663 // debug statements here
35665 // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
35667 export function ErrorAction_clone_ptr(arg: bigint): bigint {
35668 if(!isWasmInitialized) {
35669 throw new Error("initializeWasm() must be awaited first!");
35671 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
35672 return nativeResponseValue;
35674 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
35676 export function ErrorAction_clone(orig: bigint): bigint {
35677 if(!isWasmInitialized) {
35678 throw new Error("initializeWasm() must be awaited first!");
35680 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
35681 return nativeResponseValue;
35683 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
35685 export function ErrorAction_disconnect_peer(msg: bigint): bigint {
35686 if(!isWasmInitialized) {
35687 throw new Error("initializeWasm() must be awaited first!");
35689 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
35690 return nativeResponseValue;
35692 // struct LDKErrorAction ErrorAction_disconnect_peer_with_warning(struct LDKWarningMessage msg);
35694 export function ErrorAction_disconnect_peer_with_warning(msg: bigint): bigint {
35695 if(!isWasmInitialized) {
35696 throw new Error("initializeWasm() must be awaited first!");
35698 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer_with_warning(msg);
35699 return nativeResponseValue;
35701 // struct LDKErrorAction ErrorAction_ignore_error(void);
35703 export function ErrorAction_ignore_error(): bigint {
35704 if(!isWasmInitialized) {
35705 throw new Error("initializeWasm() must be awaited first!");
35707 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
35708 return nativeResponseValue;
35710 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
35712 export function ErrorAction_ignore_and_log(a: Level): bigint {
35713 if(!isWasmInitialized) {
35714 throw new Error("initializeWasm() must be awaited first!");
35716 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
35717 return nativeResponseValue;
35719 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
35721 export function ErrorAction_ignore_duplicate_gossip(): bigint {
35722 if(!isWasmInitialized) {
35723 throw new Error("initializeWasm() must be awaited first!");
35725 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
35726 return nativeResponseValue;
35728 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
35730 export function ErrorAction_send_error_message(msg: bigint): bigint {
35731 if(!isWasmInitialized) {
35732 throw new Error("initializeWasm() must be awaited first!");
35734 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
35735 return nativeResponseValue;
35737 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
35739 export function ErrorAction_send_warning_message(msg: bigint, log_level: Level): bigint {
35740 if(!isWasmInitialized) {
35741 throw new Error("initializeWasm() must be awaited first!");
35743 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
35744 return nativeResponseValue;
35746 // void LightningError_free(struct LDKLightningError this_obj);
35748 export function LightningError_free(this_obj: bigint): void {
35749 if(!isWasmInitialized) {
35750 throw new Error("initializeWasm() must be awaited first!");
35752 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
35753 // debug statements here
35755 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
35757 export function LightningError_get_err(this_ptr: bigint): number {
35758 if(!isWasmInitialized) {
35759 throw new Error("initializeWasm() must be awaited first!");
35761 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
35762 return nativeResponseValue;
35764 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
35766 export function LightningError_set_err(this_ptr: bigint, val: number): void {
35767 if(!isWasmInitialized) {
35768 throw new Error("initializeWasm() must be awaited first!");
35770 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
35771 // debug statements here
35773 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
35775 export function LightningError_get_action(this_ptr: bigint): bigint {
35776 if(!isWasmInitialized) {
35777 throw new Error("initializeWasm() must be awaited first!");
35779 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
35780 return nativeResponseValue;
35782 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
35784 export function LightningError_set_action(this_ptr: bigint, val: bigint): void {
35785 if(!isWasmInitialized) {
35786 throw new Error("initializeWasm() must be awaited first!");
35788 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
35789 // debug statements here
35791 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
35793 export function LightningError_new(err_arg: number, action_arg: bigint): bigint {
35794 if(!isWasmInitialized) {
35795 throw new Error("initializeWasm() must be awaited first!");
35797 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
35798 return nativeResponseValue;
35800 // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
35802 export function LightningError_clone_ptr(arg: bigint): bigint {
35803 if(!isWasmInitialized) {
35804 throw new Error("initializeWasm() must be awaited first!");
35806 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
35807 return nativeResponseValue;
35809 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
35811 export function LightningError_clone(orig: bigint): bigint {
35812 if(!isWasmInitialized) {
35813 throw new Error("initializeWasm() must be awaited first!");
35815 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
35816 return nativeResponseValue;
35818 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
35820 export function CommitmentUpdate_free(this_obj: bigint): void {
35821 if(!isWasmInitialized) {
35822 throw new Error("initializeWasm() must be awaited first!");
35824 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
35825 // debug statements here
35827 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35829 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: bigint): number {
35830 if(!isWasmInitialized) {
35831 throw new Error("initializeWasm() must be awaited first!");
35833 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
35834 return nativeResponseValue;
35836 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
35838 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: bigint, val: number): void {
35839 if(!isWasmInitialized) {
35840 throw new Error("initializeWasm() must be awaited first!");
35842 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
35843 // debug statements here
35845 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35847 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: bigint): number {
35848 if(!isWasmInitialized) {
35849 throw new Error("initializeWasm() must be awaited first!");
35851 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
35852 return nativeResponseValue;
35854 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
35856 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: bigint, val: number): void {
35857 if(!isWasmInitialized) {
35858 throw new Error("initializeWasm() must be awaited first!");
35860 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
35861 // debug statements here
35863 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35865 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: bigint): number {
35866 if(!isWasmInitialized) {
35867 throw new Error("initializeWasm() must be awaited first!");
35869 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
35870 return nativeResponseValue;
35872 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
35874 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: bigint, val: number): void {
35875 if(!isWasmInitialized) {
35876 throw new Error("initializeWasm() must be awaited first!");
35878 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
35879 // debug statements here
35881 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35883 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: bigint): number {
35884 if(!isWasmInitialized) {
35885 throw new Error("initializeWasm() must be awaited first!");
35887 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
35888 return nativeResponseValue;
35890 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
35892 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: bigint, val: number): void {
35893 if(!isWasmInitialized) {
35894 throw new Error("initializeWasm() must be awaited first!");
35896 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
35897 // debug statements here
35899 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35901 export function CommitmentUpdate_get_update_fee(this_ptr: bigint): bigint {
35902 if(!isWasmInitialized) {
35903 throw new Error("initializeWasm() must be awaited first!");
35905 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
35906 return nativeResponseValue;
35908 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
35910 export function CommitmentUpdate_set_update_fee(this_ptr: bigint, val: bigint): void {
35911 if(!isWasmInitialized) {
35912 throw new Error("initializeWasm() must be awaited first!");
35914 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
35915 // debug statements here
35917 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
35919 export function CommitmentUpdate_get_commitment_signed(this_ptr: bigint): bigint {
35920 if(!isWasmInitialized) {
35921 throw new Error("initializeWasm() must be awaited first!");
35923 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
35924 return nativeResponseValue;
35926 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
35928 export function CommitmentUpdate_set_commitment_signed(this_ptr: bigint, val: bigint): void {
35929 if(!isWasmInitialized) {
35930 throw new Error("initializeWasm() must be awaited first!");
35932 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
35933 // debug statements here
35935 // 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);
35937 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 {
35938 if(!isWasmInitialized) {
35939 throw new Error("initializeWasm() must be awaited first!");
35941 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);
35942 return nativeResponseValue;
35944 // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
35946 export function CommitmentUpdate_clone_ptr(arg: bigint): bigint {
35947 if(!isWasmInitialized) {
35948 throw new Error("initializeWasm() must be awaited first!");
35950 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
35951 return nativeResponseValue;
35953 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
35955 export function CommitmentUpdate_clone(orig: bigint): bigint {
35956 if(!isWasmInitialized) {
35957 throw new Error("initializeWasm() must be awaited first!");
35959 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
35960 return nativeResponseValue;
35962 // bool CommitmentUpdate_eq(const struct LDKCommitmentUpdate *NONNULL_PTR a, const struct LDKCommitmentUpdate *NONNULL_PTR b);
35964 export function CommitmentUpdate_eq(a: bigint, b: bigint): boolean {
35965 if(!isWasmInitialized) {
35966 throw new Error("initializeWasm() must be awaited first!");
35968 const nativeResponseValue = wasm.TS_CommitmentUpdate_eq(a, b);
35969 return nativeResponseValue;
35971 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
35973 export function ChannelMessageHandler_free(this_ptr: bigint): void {
35974 if(!isWasmInitialized) {
35975 throw new Error("initializeWasm() must be awaited first!");
35977 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
35978 // debug statements here
35980 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
35982 export function RoutingMessageHandler_free(this_ptr: bigint): void {
35983 if(!isWasmInitialized) {
35984 throw new Error("initializeWasm() must be awaited first!");
35986 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
35987 // debug statements here
35989 // void OnionMessageHandler_free(struct LDKOnionMessageHandler this_ptr);
35991 export function OnionMessageHandler_free(this_ptr: bigint): void {
35992 if(!isWasmInitialized) {
35993 throw new Error("initializeWasm() must be awaited first!");
35995 const nativeResponseValue = wasm.TS_OnionMessageHandler_free(this_ptr);
35996 // debug statements here
35998 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
36000 export function AcceptChannel_write(obj: bigint): number {
36001 if(!isWasmInitialized) {
36002 throw new Error("initializeWasm() must be awaited first!");
36004 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
36005 return nativeResponseValue;
36007 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
36009 export function AcceptChannel_read(ser: number): bigint {
36010 if(!isWasmInitialized) {
36011 throw new Error("initializeWasm() must be awaited first!");
36013 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
36014 return nativeResponseValue;
36016 // struct LDKCVec_u8Z AcceptChannelV2_write(const struct LDKAcceptChannelV2 *NONNULL_PTR obj);
36018 export function AcceptChannelV2_write(obj: bigint): number {
36019 if(!isWasmInitialized) {
36020 throw new Error("initializeWasm() must be awaited first!");
36022 const nativeResponseValue = wasm.TS_AcceptChannelV2_write(obj);
36023 return nativeResponseValue;
36025 // struct LDKCResult_AcceptChannelV2DecodeErrorZ AcceptChannelV2_read(struct LDKu8slice ser);
36027 export function AcceptChannelV2_read(ser: number): bigint {
36028 if(!isWasmInitialized) {
36029 throw new Error("initializeWasm() must be awaited first!");
36031 const nativeResponseValue = wasm.TS_AcceptChannelV2_read(ser);
36032 return nativeResponseValue;
36034 // struct LDKCVec_u8Z TxAddInput_write(const struct LDKTxAddInput *NONNULL_PTR obj);
36036 export function TxAddInput_write(obj: bigint): number {
36037 if(!isWasmInitialized) {
36038 throw new Error("initializeWasm() must be awaited first!");
36040 const nativeResponseValue = wasm.TS_TxAddInput_write(obj);
36041 return nativeResponseValue;
36043 // struct LDKCResult_TxAddInputDecodeErrorZ TxAddInput_read(struct LDKu8slice ser);
36045 export function TxAddInput_read(ser: number): bigint {
36046 if(!isWasmInitialized) {
36047 throw new Error("initializeWasm() must be awaited first!");
36049 const nativeResponseValue = wasm.TS_TxAddInput_read(ser);
36050 return nativeResponseValue;
36052 // struct LDKCVec_u8Z TxAddOutput_write(const struct LDKTxAddOutput *NONNULL_PTR obj);
36054 export function TxAddOutput_write(obj: bigint): number {
36055 if(!isWasmInitialized) {
36056 throw new Error("initializeWasm() must be awaited first!");
36058 const nativeResponseValue = wasm.TS_TxAddOutput_write(obj);
36059 return nativeResponseValue;
36061 // struct LDKCResult_TxAddOutputDecodeErrorZ TxAddOutput_read(struct LDKu8slice ser);
36063 export function TxAddOutput_read(ser: number): bigint {
36064 if(!isWasmInitialized) {
36065 throw new Error("initializeWasm() must be awaited first!");
36067 const nativeResponseValue = wasm.TS_TxAddOutput_read(ser);
36068 return nativeResponseValue;
36070 // struct LDKCVec_u8Z TxRemoveInput_write(const struct LDKTxRemoveInput *NONNULL_PTR obj);
36072 export function TxRemoveInput_write(obj: bigint): number {
36073 if(!isWasmInitialized) {
36074 throw new Error("initializeWasm() must be awaited first!");
36076 const nativeResponseValue = wasm.TS_TxRemoveInput_write(obj);
36077 return nativeResponseValue;
36079 // struct LDKCResult_TxRemoveInputDecodeErrorZ TxRemoveInput_read(struct LDKu8slice ser);
36081 export function TxRemoveInput_read(ser: number): bigint {
36082 if(!isWasmInitialized) {
36083 throw new Error("initializeWasm() must be awaited first!");
36085 const nativeResponseValue = wasm.TS_TxRemoveInput_read(ser);
36086 return nativeResponseValue;
36088 // struct LDKCVec_u8Z TxRemoveOutput_write(const struct LDKTxRemoveOutput *NONNULL_PTR obj);
36090 export function TxRemoveOutput_write(obj: bigint): number {
36091 if(!isWasmInitialized) {
36092 throw new Error("initializeWasm() must be awaited first!");
36094 const nativeResponseValue = wasm.TS_TxRemoveOutput_write(obj);
36095 return nativeResponseValue;
36097 // struct LDKCResult_TxRemoveOutputDecodeErrorZ TxRemoveOutput_read(struct LDKu8slice ser);
36099 export function TxRemoveOutput_read(ser: number): bigint {
36100 if(!isWasmInitialized) {
36101 throw new Error("initializeWasm() must be awaited first!");
36103 const nativeResponseValue = wasm.TS_TxRemoveOutput_read(ser);
36104 return nativeResponseValue;
36106 // struct LDKCVec_u8Z TxComplete_write(const struct LDKTxComplete *NONNULL_PTR obj);
36108 export function TxComplete_write(obj: bigint): number {
36109 if(!isWasmInitialized) {
36110 throw new Error("initializeWasm() must be awaited first!");
36112 const nativeResponseValue = wasm.TS_TxComplete_write(obj);
36113 return nativeResponseValue;
36115 // struct LDKCResult_TxCompleteDecodeErrorZ TxComplete_read(struct LDKu8slice ser);
36117 export function TxComplete_read(ser: number): bigint {
36118 if(!isWasmInitialized) {
36119 throw new Error("initializeWasm() must be awaited first!");
36121 const nativeResponseValue = wasm.TS_TxComplete_read(ser);
36122 return nativeResponseValue;
36124 // struct LDKCVec_u8Z TxSignatures_write(const struct LDKTxSignatures *NONNULL_PTR obj);
36126 export function TxSignatures_write(obj: bigint): number {
36127 if(!isWasmInitialized) {
36128 throw new Error("initializeWasm() must be awaited first!");
36130 const nativeResponseValue = wasm.TS_TxSignatures_write(obj);
36131 return nativeResponseValue;
36133 // struct LDKCResult_TxSignaturesDecodeErrorZ TxSignatures_read(struct LDKu8slice ser);
36135 export function TxSignatures_read(ser: number): bigint {
36136 if(!isWasmInitialized) {
36137 throw new Error("initializeWasm() must be awaited first!");
36139 const nativeResponseValue = wasm.TS_TxSignatures_read(ser);
36140 return nativeResponseValue;
36142 // struct LDKCVec_u8Z TxInitRbf_write(const struct LDKTxInitRbf *NONNULL_PTR obj);
36144 export function TxInitRbf_write(obj: bigint): number {
36145 if(!isWasmInitialized) {
36146 throw new Error("initializeWasm() must be awaited first!");
36148 const nativeResponseValue = wasm.TS_TxInitRbf_write(obj);
36149 return nativeResponseValue;
36151 // struct LDKCResult_TxInitRbfDecodeErrorZ TxInitRbf_read(struct LDKu8slice ser);
36153 export function TxInitRbf_read(ser: number): bigint {
36154 if(!isWasmInitialized) {
36155 throw new Error("initializeWasm() must be awaited first!");
36157 const nativeResponseValue = wasm.TS_TxInitRbf_read(ser);
36158 return nativeResponseValue;
36160 // struct LDKCVec_u8Z TxAckRbf_write(const struct LDKTxAckRbf *NONNULL_PTR obj);
36162 export function TxAckRbf_write(obj: bigint): number {
36163 if(!isWasmInitialized) {
36164 throw new Error("initializeWasm() must be awaited first!");
36166 const nativeResponseValue = wasm.TS_TxAckRbf_write(obj);
36167 return nativeResponseValue;
36169 // struct LDKCResult_TxAckRbfDecodeErrorZ TxAckRbf_read(struct LDKu8slice ser);
36171 export function TxAckRbf_read(ser: number): bigint {
36172 if(!isWasmInitialized) {
36173 throw new Error("initializeWasm() must be awaited first!");
36175 const nativeResponseValue = wasm.TS_TxAckRbf_read(ser);
36176 return nativeResponseValue;
36178 // struct LDKCVec_u8Z TxAbort_write(const struct LDKTxAbort *NONNULL_PTR obj);
36180 export function TxAbort_write(obj: bigint): number {
36181 if(!isWasmInitialized) {
36182 throw new Error("initializeWasm() must be awaited first!");
36184 const nativeResponseValue = wasm.TS_TxAbort_write(obj);
36185 return nativeResponseValue;
36187 // struct LDKCResult_TxAbortDecodeErrorZ TxAbort_read(struct LDKu8slice ser);
36189 export function TxAbort_read(ser: number): bigint {
36190 if(!isWasmInitialized) {
36191 throw new Error("initializeWasm() must be awaited first!");
36193 const nativeResponseValue = wasm.TS_TxAbort_read(ser);
36194 return nativeResponseValue;
36196 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
36198 export function AnnouncementSignatures_write(obj: bigint): number {
36199 if(!isWasmInitialized) {
36200 throw new Error("initializeWasm() must be awaited first!");
36202 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
36203 return nativeResponseValue;
36205 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
36207 export function AnnouncementSignatures_read(ser: number): bigint {
36208 if(!isWasmInitialized) {
36209 throw new Error("initializeWasm() must be awaited first!");
36211 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
36212 return nativeResponseValue;
36214 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
36216 export function ChannelReestablish_write(obj: bigint): number {
36217 if(!isWasmInitialized) {
36218 throw new Error("initializeWasm() must be awaited first!");
36220 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
36221 return nativeResponseValue;
36223 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
36225 export function ChannelReestablish_read(ser: number): bigint {
36226 if(!isWasmInitialized) {
36227 throw new Error("initializeWasm() must be awaited first!");
36229 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
36230 return nativeResponseValue;
36232 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
36234 export function ClosingSigned_write(obj: bigint): number {
36235 if(!isWasmInitialized) {
36236 throw new Error("initializeWasm() must be awaited first!");
36238 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
36239 return nativeResponseValue;
36241 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
36243 export function ClosingSigned_read(ser: number): bigint {
36244 if(!isWasmInitialized) {
36245 throw new Error("initializeWasm() must be awaited first!");
36247 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
36248 return nativeResponseValue;
36250 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
36252 export function ClosingSignedFeeRange_write(obj: bigint): number {
36253 if(!isWasmInitialized) {
36254 throw new Error("initializeWasm() must be awaited first!");
36256 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
36257 return nativeResponseValue;
36259 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
36261 export function ClosingSignedFeeRange_read(ser: number): bigint {
36262 if(!isWasmInitialized) {
36263 throw new Error("initializeWasm() must be awaited first!");
36265 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
36266 return nativeResponseValue;
36268 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
36270 export function CommitmentSigned_write(obj: bigint): number {
36271 if(!isWasmInitialized) {
36272 throw new Error("initializeWasm() must be awaited first!");
36274 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
36275 return nativeResponseValue;
36277 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
36279 export function CommitmentSigned_read(ser: number): bigint {
36280 if(!isWasmInitialized) {
36281 throw new Error("initializeWasm() must be awaited first!");
36283 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
36284 return nativeResponseValue;
36286 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
36288 export function FundingCreated_write(obj: bigint): number {
36289 if(!isWasmInitialized) {
36290 throw new Error("initializeWasm() must be awaited first!");
36292 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
36293 return nativeResponseValue;
36295 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
36297 export function FundingCreated_read(ser: number): bigint {
36298 if(!isWasmInitialized) {
36299 throw new Error("initializeWasm() must be awaited first!");
36301 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
36302 return nativeResponseValue;
36304 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
36306 export function FundingSigned_write(obj: bigint): number {
36307 if(!isWasmInitialized) {
36308 throw new Error("initializeWasm() must be awaited first!");
36310 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
36311 return nativeResponseValue;
36313 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
36315 export function FundingSigned_read(ser: number): bigint {
36316 if(!isWasmInitialized) {
36317 throw new Error("initializeWasm() must be awaited first!");
36319 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
36320 return nativeResponseValue;
36322 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
36324 export function ChannelReady_write(obj: bigint): number {
36325 if(!isWasmInitialized) {
36326 throw new Error("initializeWasm() must be awaited first!");
36328 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
36329 return nativeResponseValue;
36331 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
36333 export function ChannelReady_read(ser: number): bigint {
36334 if(!isWasmInitialized) {
36335 throw new Error("initializeWasm() must be awaited first!");
36337 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
36338 return nativeResponseValue;
36340 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
36342 export function Init_write(obj: bigint): number {
36343 if(!isWasmInitialized) {
36344 throw new Error("initializeWasm() must be awaited first!");
36346 const nativeResponseValue = wasm.TS_Init_write(obj);
36347 return nativeResponseValue;
36349 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
36351 export function Init_read(ser: number): bigint {
36352 if(!isWasmInitialized) {
36353 throw new Error("initializeWasm() must be awaited first!");
36355 const nativeResponseValue = wasm.TS_Init_read(ser);
36356 return nativeResponseValue;
36358 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
36360 export function OpenChannel_write(obj: bigint): number {
36361 if(!isWasmInitialized) {
36362 throw new Error("initializeWasm() must be awaited first!");
36364 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
36365 return nativeResponseValue;
36367 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
36369 export function OpenChannel_read(ser: number): bigint {
36370 if(!isWasmInitialized) {
36371 throw new Error("initializeWasm() must be awaited first!");
36373 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
36374 return nativeResponseValue;
36376 // struct LDKCVec_u8Z OpenChannelV2_write(const struct LDKOpenChannelV2 *NONNULL_PTR obj);
36378 export function OpenChannelV2_write(obj: bigint): number {
36379 if(!isWasmInitialized) {
36380 throw new Error("initializeWasm() must be awaited first!");
36382 const nativeResponseValue = wasm.TS_OpenChannelV2_write(obj);
36383 return nativeResponseValue;
36385 // struct LDKCResult_OpenChannelV2DecodeErrorZ OpenChannelV2_read(struct LDKu8slice ser);
36387 export function OpenChannelV2_read(ser: number): bigint {
36388 if(!isWasmInitialized) {
36389 throw new Error("initializeWasm() must be awaited first!");
36391 const nativeResponseValue = wasm.TS_OpenChannelV2_read(ser);
36392 return nativeResponseValue;
36394 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
36396 export function RevokeAndACK_write(obj: bigint): number {
36397 if(!isWasmInitialized) {
36398 throw new Error("initializeWasm() must be awaited first!");
36400 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
36401 return nativeResponseValue;
36403 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
36405 export function RevokeAndACK_read(ser: number): bigint {
36406 if(!isWasmInitialized) {
36407 throw new Error("initializeWasm() must be awaited first!");
36409 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
36410 return nativeResponseValue;
36412 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
36414 export function Shutdown_write(obj: bigint): number {
36415 if(!isWasmInitialized) {
36416 throw new Error("initializeWasm() must be awaited first!");
36418 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
36419 return nativeResponseValue;
36421 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
36423 export function Shutdown_read(ser: number): bigint {
36424 if(!isWasmInitialized) {
36425 throw new Error("initializeWasm() must be awaited first!");
36427 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
36428 return nativeResponseValue;
36430 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
36432 export function UpdateFailHTLC_write(obj: bigint): number {
36433 if(!isWasmInitialized) {
36434 throw new Error("initializeWasm() must be awaited first!");
36436 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
36437 return nativeResponseValue;
36439 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
36441 export function UpdateFailHTLC_read(ser: number): bigint {
36442 if(!isWasmInitialized) {
36443 throw new Error("initializeWasm() must be awaited first!");
36445 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
36446 return nativeResponseValue;
36448 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
36450 export function UpdateFailMalformedHTLC_write(obj: bigint): number {
36451 if(!isWasmInitialized) {
36452 throw new Error("initializeWasm() must be awaited first!");
36454 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
36455 return nativeResponseValue;
36457 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
36459 export function UpdateFailMalformedHTLC_read(ser: number): bigint {
36460 if(!isWasmInitialized) {
36461 throw new Error("initializeWasm() must be awaited first!");
36463 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
36464 return nativeResponseValue;
36466 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
36468 export function UpdateFee_write(obj: bigint): number {
36469 if(!isWasmInitialized) {
36470 throw new Error("initializeWasm() must be awaited first!");
36472 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
36473 return nativeResponseValue;
36475 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
36477 export function UpdateFee_read(ser: number): bigint {
36478 if(!isWasmInitialized) {
36479 throw new Error("initializeWasm() must be awaited first!");
36481 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
36482 return nativeResponseValue;
36484 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
36486 export function UpdateFulfillHTLC_write(obj: bigint): number {
36487 if(!isWasmInitialized) {
36488 throw new Error("initializeWasm() must be awaited first!");
36490 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
36491 return nativeResponseValue;
36493 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
36495 export function UpdateFulfillHTLC_read(ser: number): bigint {
36496 if(!isWasmInitialized) {
36497 throw new Error("initializeWasm() must be awaited first!");
36499 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
36500 return nativeResponseValue;
36502 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
36504 export function UpdateAddHTLC_write(obj: bigint): number {
36505 if(!isWasmInitialized) {
36506 throw new Error("initializeWasm() must be awaited first!");
36508 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
36509 return nativeResponseValue;
36511 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
36513 export function UpdateAddHTLC_read(ser: number): bigint {
36514 if(!isWasmInitialized) {
36515 throw new Error("initializeWasm() must be awaited first!");
36517 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
36518 return nativeResponseValue;
36520 // struct LDKCResult_OnionMessageDecodeErrorZ OnionMessage_read(struct LDKu8slice ser);
36522 export function OnionMessage_read(ser: number): bigint {
36523 if(!isWasmInitialized) {
36524 throw new Error("initializeWasm() must be awaited first!");
36526 const nativeResponseValue = wasm.TS_OnionMessage_read(ser);
36527 return nativeResponseValue;
36529 // struct LDKCVec_u8Z OnionMessage_write(const struct LDKOnionMessage *NONNULL_PTR obj);
36531 export function OnionMessage_write(obj: bigint): number {
36532 if(!isWasmInitialized) {
36533 throw new Error("initializeWasm() must be awaited first!");
36535 const nativeResponseValue = wasm.TS_OnionMessage_write(obj);
36536 return nativeResponseValue;
36538 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
36540 export function Ping_write(obj: bigint): number {
36541 if(!isWasmInitialized) {
36542 throw new Error("initializeWasm() must be awaited first!");
36544 const nativeResponseValue = wasm.TS_Ping_write(obj);
36545 return nativeResponseValue;
36547 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
36549 export function Ping_read(ser: number): bigint {
36550 if(!isWasmInitialized) {
36551 throw new Error("initializeWasm() must be awaited first!");
36553 const nativeResponseValue = wasm.TS_Ping_read(ser);
36554 return nativeResponseValue;
36556 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
36558 export function Pong_write(obj: bigint): number {
36559 if(!isWasmInitialized) {
36560 throw new Error("initializeWasm() must be awaited first!");
36562 const nativeResponseValue = wasm.TS_Pong_write(obj);
36563 return nativeResponseValue;
36565 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
36567 export function Pong_read(ser: number): bigint {
36568 if(!isWasmInitialized) {
36569 throw new Error("initializeWasm() must be awaited first!");
36571 const nativeResponseValue = wasm.TS_Pong_read(ser);
36572 return nativeResponseValue;
36574 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
36576 export function UnsignedChannelAnnouncement_write(obj: bigint): number {
36577 if(!isWasmInitialized) {
36578 throw new Error("initializeWasm() must be awaited first!");
36580 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
36581 return nativeResponseValue;
36583 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
36585 export function UnsignedChannelAnnouncement_read(ser: number): bigint {
36586 if(!isWasmInitialized) {
36587 throw new Error("initializeWasm() must be awaited first!");
36589 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
36590 return nativeResponseValue;
36592 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
36594 export function ChannelAnnouncement_write(obj: bigint): number {
36595 if(!isWasmInitialized) {
36596 throw new Error("initializeWasm() must be awaited first!");
36598 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
36599 return nativeResponseValue;
36601 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
36603 export function ChannelAnnouncement_read(ser: number): bigint {
36604 if(!isWasmInitialized) {
36605 throw new Error("initializeWasm() must be awaited first!");
36607 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
36608 return nativeResponseValue;
36610 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
36612 export function UnsignedChannelUpdate_write(obj: bigint): number {
36613 if(!isWasmInitialized) {
36614 throw new Error("initializeWasm() must be awaited first!");
36616 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
36617 return nativeResponseValue;
36619 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
36621 export function UnsignedChannelUpdate_read(ser: number): bigint {
36622 if(!isWasmInitialized) {
36623 throw new Error("initializeWasm() must be awaited first!");
36625 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
36626 return nativeResponseValue;
36628 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
36630 export function ChannelUpdate_write(obj: bigint): number {
36631 if(!isWasmInitialized) {
36632 throw new Error("initializeWasm() must be awaited first!");
36634 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
36635 return nativeResponseValue;
36637 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
36639 export function ChannelUpdate_read(ser: number): bigint {
36640 if(!isWasmInitialized) {
36641 throw new Error("initializeWasm() must be awaited first!");
36643 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
36644 return nativeResponseValue;
36646 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
36648 export function ErrorMessage_write(obj: bigint): number {
36649 if(!isWasmInitialized) {
36650 throw new Error("initializeWasm() must be awaited first!");
36652 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
36653 return nativeResponseValue;
36655 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
36657 export function ErrorMessage_read(ser: number): bigint {
36658 if(!isWasmInitialized) {
36659 throw new Error("initializeWasm() must be awaited first!");
36661 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
36662 return nativeResponseValue;
36664 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
36666 export function WarningMessage_write(obj: bigint): number {
36667 if(!isWasmInitialized) {
36668 throw new Error("initializeWasm() must be awaited first!");
36670 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
36671 return nativeResponseValue;
36673 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
36675 export function WarningMessage_read(ser: number): bigint {
36676 if(!isWasmInitialized) {
36677 throw new Error("initializeWasm() must be awaited first!");
36679 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
36680 return nativeResponseValue;
36682 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
36684 export function UnsignedNodeAnnouncement_write(obj: bigint): number {
36685 if(!isWasmInitialized) {
36686 throw new Error("initializeWasm() must be awaited first!");
36688 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
36689 return nativeResponseValue;
36691 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
36693 export function UnsignedNodeAnnouncement_read(ser: number): bigint {
36694 if(!isWasmInitialized) {
36695 throw new Error("initializeWasm() must be awaited first!");
36697 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
36698 return nativeResponseValue;
36700 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
36702 export function NodeAnnouncement_write(obj: bigint): number {
36703 if(!isWasmInitialized) {
36704 throw new Error("initializeWasm() must be awaited first!");
36706 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
36707 return nativeResponseValue;
36709 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
36711 export function NodeAnnouncement_read(ser: number): bigint {
36712 if(!isWasmInitialized) {
36713 throw new Error("initializeWasm() must be awaited first!");
36715 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
36716 return nativeResponseValue;
36718 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
36720 export function QueryShortChannelIds_read(ser: number): bigint {
36721 if(!isWasmInitialized) {
36722 throw new Error("initializeWasm() must be awaited first!");
36724 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
36725 return nativeResponseValue;
36727 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
36729 export function QueryShortChannelIds_write(obj: bigint): number {
36730 if(!isWasmInitialized) {
36731 throw new Error("initializeWasm() must be awaited first!");
36733 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
36734 return nativeResponseValue;
36736 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
36738 export function ReplyShortChannelIdsEnd_write(obj: bigint): number {
36739 if(!isWasmInitialized) {
36740 throw new Error("initializeWasm() must be awaited first!");
36742 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
36743 return nativeResponseValue;
36745 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
36747 export function ReplyShortChannelIdsEnd_read(ser: number): bigint {
36748 if(!isWasmInitialized) {
36749 throw new Error("initializeWasm() must be awaited first!");
36751 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
36752 return nativeResponseValue;
36754 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
36756 export function QueryChannelRange_end_blocknum(this_arg: bigint): number {
36757 if(!isWasmInitialized) {
36758 throw new Error("initializeWasm() must be awaited first!");
36760 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
36761 return nativeResponseValue;
36763 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
36765 export function QueryChannelRange_write(obj: bigint): number {
36766 if(!isWasmInitialized) {
36767 throw new Error("initializeWasm() must be awaited first!");
36769 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
36770 return nativeResponseValue;
36772 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
36774 export function QueryChannelRange_read(ser: number): bigint {
36775 if(!isWasmInitialized) {
36776 throw new Error("initializeWasm() must be awaited first!");
36778 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
36779 return nativeResponseValue;
36781 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
36783 export function ReplyChannelRange_read(ser: number): bigint {
36784 if(!isWasmInitialized) {
36785 throw new Error("initializeWasm() must be awaited first!");
36787 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
36788 return nativeResponseValue;
36790 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
36792 export function ReplyChannelRange_write(obj: bigint): number {
36793 if(!isWasmInitialized) {
36794 throw new Error("initializeWasm() must be awaited first!");
36796 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
36797 return nativeResponseValue;
36799 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
36801 export function GossipTimestampFilter_write(obj: bigint): number {
36802 if(!isWasmInitialized) {
36803 throw new Error("initializeWasm() must be awaited first!");
36805 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
36806 return nativeResponseValue;
36808 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
36810 export function GossipTimestampFilter_read(ser: number): bigint {
36811 if(!isWasmInitialized) {
36812 throw new Error("initializeWasm() must be awaited first!");
36814 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
36815 return nativeResponseValue;
36817 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
36819 export function CustomMessageHandler_free(this_ptr: bigint): void {
36820 if(!isWasmInitialized) {
36821 throw new Error("initializeWasm() must be awaited first!");
36823 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
36824 // debug statements here
36826 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
36828 export function IgnoringMessageHandler_free(this_obj: bigint): void {
36829 if(!isWasmInitialized) {
36830 throw new Error("initializeWasm() must be awaited first!");
36832 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
36833 // debug statements here
36835 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
36837 export function IgnoringMessageHandler_new(): bigint {
36838 if(!isWasmInitialized) {
36839 throw new Error("initializeWasm() must be awaited first!");
36841 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
36842 return nativeResponseValue;
36844 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36846 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
36847 if(!isWasmInitialized) {
36848 throw new Error("initializeWasm() must be awaited first!");
36850 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
36851 return nativeResponseValue;
36853 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36855 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: bigint): bigint {
36856 if(!isWasmInitialized) {
36857 throw new Error("initializeWasm() must be awaited first!");
36859 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
36860 return nativeResponseValue;
36862 // struct LDKOnionMessageHandler IgnoringMessageHandler_as_OnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36864 export function IgnoringMessageHandler_as_OnionMessageHandler(this_arg: bigint): bigint {
36865 if(!isWasmInitialized) {
36866 throw new Error("initializeWasm() must be awaited first!");
36868 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageHandler(this_arg);
36869 return nativeResponseValue;
36871 // struct LDKOffersMessageHandler IgnoringMessageHandler_as_OffersMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36873 export function IgnoringMessageHandler_as_OffersMessageHandler(this_arg: bigint): bigint {
36874 if(!isWasmInitialized) {
36875 throw new Error("initializeWasm() must be awaited first!");
36877 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OffersMessageHandler(this_arg);
36878 return nativeResponseValue;
36880 // struct LDKCustomOnionMessageHandler IgnoringMessageHandler_as_CustomOnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36882 export function IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg: bigint): bigint {
36883 if(!isWasmInitialized) {
36884 throw new Error("initializeWasm() must be awaited first!");
36886 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg);
36887 return nativeResponseValue;
36889 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36891 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: bigint): bigint {
36892 if(!isWasmInitialized) {
36893 throw new Error("initializeWasm() must be awaited first!");
36895 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
36896 return nativeResponseValue;
36898 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
36900 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: bigint): bigint {
36901 if(!isWasmInitialized) {
36902 throw new Error("initializeWasm() must be awaited first!");
36904 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
36905 return nativeResponseValue;
36907 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
36909 export function ErroringMessageHandler_free(this_obj: bigint): void {
36910 if(!isWasmInitialized) {
36911 throw new Error("initializeWasm() must be awaited first!");
36913 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
36914 // debug statements here
36916 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
36918 export function ErroringMessageHandler_new(): bigint {
36919 if(!isWasmInitialized) {
36920 throw new Error("initializeWasm() must be awaited first!");
36922 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
36923 return nativeResponseValue;
36925 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
36927 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
36928 if(!isWasmInitialized) {
36929 throw new Error("initializeWasm() must be awaited first!");
36931 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
36932 return nativeResponseValue;
36934 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
36936 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: bigint): bigint {
36937 if(!isWasmInitialized) {
36938 throw new Error("initializeWasm() must be awaited first!");
36940 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
36941 return nativeResponseValue;
36943 // void MessageHandler_free(struct LDKMessageHandler this_obj);
36945 export function MessageHandler_free(this_obj: bigint): void {
36946 if(!isWasmInitialized) {
36947 throw new Error("initializeWasm() must be awaited first!");
36949 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
36950 // debug statements here
36952 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
36954 export function MessageHandler_get_chan_handler(this_ptr: bigint): bigint {
36955 if(!isWasmInitialized) {
36956 throw new Error("initializeWasm() must be awaited first!");
36958 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
36959 return nativeResponseValue;
36961 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
36963 export function MessageHandler_set_chan_handler(this_ptr: bigint, val: bigint): void {
36964 if(!isWasmInitialized) {
36965 throw new Error("initializeWasm() must be awaited first!");
36967 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
36968 // debug statements here
36970 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
36972 export function MessageHandler_get_route_handler(this_ptr: bigint): bigint {
36973 if(!isWasmInitialized) {
36974 throw new Error("initializeWasm() must be awaited first!");
36976 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
36977 return nativeResponseValue;
36979 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
36981 export function MessageHandler_set_route_handler(this_ptr: bigint, val: bigint): void {
36982 if(!isWasmInitialized) {
36983 throw new Error("initializeWasm() must be awaited first!");
36985 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
36986 // debug statements here
36988 // const struct LDKOnionMessageHandler *MessageHandler_get_onion_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
36990 export function MessageHandler_get_onion_message_handler(this_ptr: bigint): bigint {
36991 if(!isWasmInitialized) {
36992 throw new Error("initializeWasm() must be awaited first!");
36994 const nativeResponseValue = wasm.TS_MessageHandler_get_onion_message_handler(this_ptr);
36995 return nativeResponseValue;
36997 // void MessageHandler_set_onion_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKOnionMessageHandler val);
36999 export function MessageHandler_set_onion_message_handler(this_ptr: bigint, val: bigint): void {
37000 if(!isWasmInitialized) {
37001 throw new Error("initializeWasm() must be awaited first!");
37003 const nativeResponseValue = wasm.TS_MessageHandler_set_onion_message_handler(this_ptr, val);
37004 // debug statements here
37006 // const struct LDKCustomMessageHandler *MessageHandler_get_custom_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
37008 export function MessageHandler_get_custom_message_handler(this_ptr: bigint): bigint {
37009 if(!isWasmInitialized) {
37010 throw new Error("initializeWasm() must be awaited first!");
37012 const nativeResponseValue = wasm.TS_MessageHandler_get_custom_message_handler(this_ptr);
37013 return nativeResponseValue;
37015 // void MessageHandler_set_custom_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKCustomMessageHandler val);
37017 export function MessageHandler_set_custom_message_handler(this_ptr: bigint, val: bigint): void {
37018 if(!isWasmInitialized) {
37019 throw new Error("initializeWasm() must be awaited first!");
37021 const nativeResponseValue = wasm.TS_MessageHandler_set_custom_message_handler(this_ptr, val);
37022 // debug statements here
37024 // 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);
37026 export function MessageHandler_new(chan_handler_arg: bigint, route_handler_arg: bigint, onion_message_handler_arg: bigint, custom_message_handler_arg: bigint): bigint {
37027 if(!isWasmInitialized) {
37028 throw new Error("initializeWasm() must be awaited first!");
37030 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg, onion_message_handler_arg, custom_message_handler_arg);
37031 return nativeResponseValue;
37033 // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
37035 export function SocketDescriptor_clone_ptr(arg: bigint): bigint {
37036 if(!isWasmInitialized) {
37037 throw new Error("initializeWasm() must be awaited first!");
37039 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
37040 return nativeResponseValue;
37042 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
37044 export function SocketDescriptor_clone(orig: bigint): bigint {
37045 if(!isWasmInitialized) {
37046 throw new Error("initializeWasm() must be awaited first!");
37048 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
37049 return nativeResponseValue;
37051 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
37053 export function SocketDescriptor_free(this_ptr: bigint): void {
37054 if(!isWasmInitialized) {
37055 throw new Error("initializeWasm() must be awaited first!");
37057 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
37058 // debug statements here
37060 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
37062 export function PeerHandleError_free(this_obj: bigint): void {
37063 if(!isWasmInitialized) {
37064 throw new Error("initializeWasm() must be awaited first!");
37066 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
37067 // debug statements here
37069 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(void);
37071 export function PeerHandleError_new(): bigint {
37072 if(!isWasmInitialized) {
37073 throw new Error("initializeWasm() must be awaited first!");
37075 const nativeResponseValue = wasm.TS_PeerHandleError_new();
37076 return nativeResponseValue;
37078 // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
37080 export function PeerHandleError_clone_ptr(arg: bigint): bigint {
37081 if(!isWasmInitialized) {
37082 throw new Error("initializeWasm() must be awaited first!");
37084 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
37085 return nativeResponseValue;
37087 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
37089 export function PeerHandleError_clone(orig: bigint): bigint {
37090 if(!isWasmInitialized) {
37091 throw new Error("initializeWasm() must be awaited first!");
37093 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
37094 return nativeResponseValue;
37096 // void PeerManager_free(struct LDKPeerManager this_obj);
37098 export function PeerManager_free(this_obj: bigint): void {
37099 if(!isWasmInitialized) {
37100 throw new Error("initializeWasm() must be awaited first!");
37102 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
37103 // debug statements here
37105 // 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);
37107 export function PeerManager_new(message_handler: bigint, current_time: number, ephemeral_random_data: number, logger: bigint, node_signer: bigint): bigint {
37108 if(!isWasmInitialized) {
37109 throw new Error("initializeWasm() must be awaited first!");
37111 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, current_time, ephemeral_random_data, logger, node_signer);
37112 return nativeResponseValue;
37114 // MUST_USE_RES struct LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
37116 export function PeerManager_get_peer_node_ids(this_arg: bigint): number {
37117 if(!isWasmInitialized) {
37118 throw new Error("initializeWasm() must be awaited first!");
37120 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
37121 return nativeResponseValue;
37123 // 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);
37125 export function PeerManager_new_outbound_connection(this_arg: bigint, their_node_id: number, descriptor: bigint, remote_network_address: bigint): bigint {
37126 if(!isWasmInitialized) {
37127 throw new Error("initializeWasm() must be awaited first!");
37129 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
37130 return nativeResponseValue;
37132 // 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);
37134 export function PeerManager_new_inbound_connection(this_arg: bigint, descriptor: bigint, remote_network_address: bigint): bigint {
37135 if(!isWasmInitialized) {
37136 throw new Error("initializeWasm() must be awaited first!");
37138 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
37139 return nativeResponseValue;
37141 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
37143 export function PeerManager_write_buffer_space_avail(this_arg: bigint, descriptor: bigint): bigint {
37144 if(!isWasmInitialized) {
37145 throw new Error("initializeWasm() must be awaited first!");
37147 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
37148 return nativeResponseValue;
37150 // 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);
37152 export function PeerManager_read_event(this_arg: bigint, peer_descriptor: bigint, data: number): bigint {
37153 if(!isWasmInitialized) {
37154 throw new Error("initializeWasm() must be awaited first!");
37156 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
37157 return nativeResponseValue;
37159 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
37161 export function PeerManager_process_events(this_arg: bigint): void {
37162 if(!isWasmInitialized) {
37163 throw new Error("initializeWasm() must be awaited first!");
37165 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
37166 // debug statements here
37168 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
37170 export function PeerManager_socket_disconnected(this_arg: bigint, descriptor: bigint): void {
37171 if(!isWasmInitialized) {
37172 throw new Error("initializeWasm() must be awaited first!");
37174 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
37175 // debug statements here
37177 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
37179 export function PeerManager_disconnect_by_node_id(this_arg: bigint, node_id: number): void {
37180 if(!isWasmInitialized) {
37181 throw new Error("initializeWasm() must be awaited first!");
37183 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id);
37184 // debug statements here
37186 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
37188 export function PeerManager_disconnect_all_peers(this_arg: bigint): void {
37189 if(!isWasmInitialized) {
37190 throw new Error("initializeWasm() must be awaited first!");
37192 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
37193 // debug statements here
37195 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
37197 export function PeerManager_timer_tick_occurred(this_arg: bigint): void {
37198 if(!isWasmInitialized) {
37199 throw new Error("initializeWasm() must be awaited first!");
37201 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
37202 // debug statements here
37204 // void PeerManager_broadcast_node_announcement(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_SocketAddressZ addresses);
37206 export function PeerManager_broadcast_node_announcement(this_arg: bigint, rgb: number, alias: number, addresses: number): void {
37207 if(!isWasmInitialized) {
37208 throw new Error("initializeWasm() must be awaited first!");
37210 const nativeResponseValue = wasm.TS_PeerManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
37211 // debug statements here
37213 // uint64_t htlc_success_tx_weight(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
37215 export function htlc_success_tx_weight(channel_type_features: bigint): bigint {
37216 if(!isWasmInitialized) {
37217 throw new Error("initializeWasm() must be awaited first!");
37219 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(channel_type_features);
37220 return nativeResponseValue;
37222 // uint64_t htlc_timeout_tx_weight(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
37224 export function htlc_timeout_tx_weight(channel_type_features: bigint): bigint {
37225 if(!isWasmInitialized) {
37226 throw new Error("initializeWasm() must be awaited first!");
37228 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(channel_type_features);
37229 return nativeResponseValue;
37231 // enum LDKHTLCClaim HTLCClaim_clone(const enum LDKHTLCClaim *NONNULL_PTR orig);
37233 export function HTLCClaim_clone(orig: bigint): HTLCClaim {
37234 if(!isWasmInitialized) {
37235 throw new Error("initializeWasm() must be awaited first!");
37237 const nativeResponseValue = wasm.TS_HTLCClaim_clone(orig);
37238 return nativeResponseValue;
37240 // enum LDKHTLCClaim HTLCClaim_offered_timeout(void);
37242 export function HTLCClaim_offered_timeout(): HTLCClaim {
37243 if(!isWasmInitialized) {
37244 throw new Error("initializeWasm() must be awaited first!");
37246 const nativeResponseValue = wasm.TS_HTLCClaim_offered_timeout();
37247 return nativeResponseValue;
37249 // enum LDKHTLCClaim HTLCClaim_offered_preimage(void);
37251 export function HTLCClaim_offered_preimage(): HTLCClaim {
37252 if(!isWasmInitialized) {
37253 throw new Error("initializeWasm() must be awaited first!");
37255 const nativeResponseValue = wasm.TS_HTLCClaim_offered_preimage();
37256 return nativeResponseValue;
37258 // enum LDKHTLCClaim HTLCClaim_accepted_timeout(void);
37260 export function HTLCClaim_accepted_timeout(): HTLCClaim {
37261 if(!isWasmInitialized) {
37262 throw new Error("initializeWasm() must be awaited first!");
37264 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_timeout();
37265 return nativeResponseValue;
37267 // enum LDKHTLCClaim HTLCClaim_accepted_preimage(void);
37269 export function HTLCClaim_accepted_preimage(): HTLCClaim {
37270 if(!isWasmInitialized) {
37271 throw new Error("initializeWasm() must be awaited first!");
37273 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_preimage();
37274 return nativeResponseValue;
37276 // enum LDKHTLCClaim HTLCClaim_revocation(void);
37278 export function HTLCClaim_revocation(): HTLCClaim {
37279 if(!isWasmInitialized) {
37280 throw new Error("initializeWasm() must be awaited first!");
37282 const nativeResponseValue = wasm.TS_HTLCClaim_revocation();
37283 return nativeResponseValue;
37285 // bool HTLCClaim_eq(const enum LDKHTLCClaim *NONNULL_PTR a, const enum LDKHTLCClaim *NONNULL_PTR b);
37287 export function HTLCClaim_eq(a: bigint, b: bigint): boolean {
37288 if(!isWasmInitialized) {
37289 throw new Error("initializeWasm() must be awaited first!");
37291 const nativeResponseValue = wasm.TS_HTLCClaim_eq(a, b);
37292 return nativeResponseValue;
37294 // MUST_USE_RES struct LDKCOption_HTLCClaimZ HTLCClaim_from_witness(struct LDKWitness witness);
37296 export function HTLCClaim_from_witness(witness: number): bigint {
37297 if(!isWasmInitialized) {
37298 throw new Error("initializeWasm() must be awaited first!");
37300 const nativeResponseValue = wasm.TS_HTLCClaim_from_witness(witness);
37301 return nativeResponseValue;
37303 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
37305 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
37306 if(!isWasmInitialized) {
37307 throw new Error("initializeWasm() must be awaited first!");
37309 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
37310 return nativeResponseValue;
37312 // 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);
37314 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 {
37315 if(!isWasmInitialized) {
37316 throw new Error("initializeWasm() must be awaited first!");
37318 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
37319 return nativeResponseValue;
37321 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
37323 export function CounterpartyCommitmentSecrets_free(this_obj: bigint): void {
37324 if(!isWasmInitialized) {
37325 throw new Error("initializeWasm() must be awaited first!");
37327 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
37328 // debug statements here
37330 // uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
37332 export function CounterpartyCommitmentSecrets_clone_ptr(arg: bigint): bigint {
37333 if(!isWasmInitialized) {
37334 throw new Error("initializeWasm() must be awaited first!");
37336 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
37337 return nativeResponseValue;
37339 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
37341 export function CounterpartyCommitmentSecrets_clone(orig: bigint): bigint {
37342 if(!isWasmInitialized) {
37343 throw new Error("initializeWasm() must be awaited first!");
37345 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
37346 return nativeResponseValue;
37348 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
37350 export function CounterpartyCommitmentSecrets_new(): bigint {
37351 if(!isWasmInitialized) {
37352 throw new Error("initializeWasm() must be awaited first!");
37354 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
37355 return nativeResponseValue;
37357 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
37359 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: bigint): bigint {
37360 if(!isWasmInitialized) {
37361 throw new Error("initializeWasm() must be awaited first!");
37363 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
37364 return nativeResponseValue;
37366 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
37368 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: bigint, idx: bigint, secret: number): bigint {
37369 if(!isWasmInitialized) {
37370 throw new Error("initializeWasm() must be awaited first!");
37372 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
37373 return nativeResponseValue;
37375 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
37377 export function CounterpartyCommitmentSecrets_get_secret(this_arg: bigint, idx: bigint): number {
37378 if(!isWasmInitialized) {
37379 throw new Error("initializeWasm() must be awaited first!");
37381 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
37382 return nativeResponseValue;
37384 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
37386 export function CounterpartyCommitmentSecrets_write(obj: bigint): number {
37387 if(!isWasmInitialized) {
37388 throw new Error("initializeWasm() must be awaited first!");
37390 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
37391 return nativeResponseValue;
37393 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
37395 export function CounterpartyCommitmentSecrets_read(ser: number): bigint {
37396 if(!isWasmInitialized) {
37397 throw new Error("initializeWasm() must be awaited first!");
37399 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
37400 return nativeResponseValue;
37402 // struct LDKSecretKey derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
37404 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
37405 if(!isWasmInitialized) {
37406 throw new Error("initializeWasm() must be awaited first!");
37408 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
37409 return nativeResponseValue;
37411 // struct LDKPublicKey derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
37413 export function derive_public_key(per_commitment_point: number, base_point: number): number {
37414 if(!isWasmInitialized) {
37415 throw new Error("initializeWasm() must be awaited first!");
37417 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
37418 return nativeResponseValue;
37420 // struct LDKSecretKey derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
37422 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
37423 if(!isWasmInitialized) {
37424 throw new Error("initializeWasm() must be awaited first!");
37426 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
37427 return nativeResponseValue;
37429 // struct LDKPublicKey derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
37431 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
37432 if(!isWasmInitialized) {
37433 throw new Error("initializeWasm() must be awaited first!");
37435 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
37436 return nativeResponseValue;
37438 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
37440 export function TxCreationKeys_free(this_obj: bigint): void {
37441 if(!isWasmInitialized) {
37442 throw new Error("initializeWasm() must be awaited first!");
37444 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
37445 // debug statements here
37447 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
37449 export function TxCreationKeys_get_per_commitment_point(this_ptr: bigint): number {
37450 if(!isWasmInitialized) {
37451 throw new Error("initializeWasm() must be awaited first!");
37453 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
37454 return nativeResponseValue;
37456 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37458 export function TxCreationKeys_set_per_commitment_point(this_ptr: bigint, val: number): void {
37459 if(!isWasmInitialized) {
37460 throw new Error("initializeWasm() must be awaited first!");
37462 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
37463 // debug statements here
37465 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
37467 export function TxCreationKeys_get_revocation_key(this_ptr: bigint): number {
37468 if(!isWasmInitialized) {
37469 throw new Error("initializeWasm() must be awaited first!");
37471 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
37472 return nativeResponseValue;
37474 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37476 export function TxCreationKeys_set_revocation_key(this_ptr: bigint, val: number): void {
37477 if(!isWasmInitialized) {
37478 throw new Error("initializeWasm() must be awaited first!");
37480 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
37481 // debug statements here
37483 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
37485 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: bigint): number {
37486 if(!isWasmInitialized) {
37487 throw new Error("initializeWasm() must be awaited first!");
37489 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
37490 return nativeResponseValue;
37492 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37494 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: bigint, val: number): void {
37495 if(!isWasmInitialized) {
37496 throw new Error("initializeWasm() must be awaited first!");
37498 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
37499 // debug statements here
37501 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
37503 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: bigint): number {
37504 if(!isWasmInitialized) {
37505 throw new Error("initializeWasm() must be awaited first!");
37507 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
37508 return nativeResponseValue;
37510 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37512 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: bigint, val: number): void {
37513 if(!isWasmInitialized) {
37514 throw new Error("initializeWasm() must be awaited first!");
37516 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
37517 // debug statements here
37519 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
37521 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: bigint): number {
37522 if(!isWasmInitialized) {
37523 throw new Error("initializeWasm() must be awaited first!");
37525 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
37526 return nativeResponseValue;
37528 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37530 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: bigint, val: number): void {
37531 if(!isWasmInitialized) {
37532 throw new Error("initializeWasm() must be awaited first!");
37534 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
37535 // debug statements here
37537 // MUST_USE_RES struct LDKTxCreationKeys TxCreationKeys_new(struct LDKPublicKey per_commitment_point_arg, struct LDKPublicKey revocation_key_arg, struct LDKPublicKey broadcaster_htlc_key_arg, struct LDKPublicKey countersignatory_htlc_key_arg, struct LDKPublicKey broadcaster_delayed_payment_key_arg);
37539 export function TxCreationKeys_new(per_commitment_point_arg: number, revocation_key_arg: number, broadcaster_htlc_key_arg: number, countersignatory_htlc_key_arg: number, broadcaster_delayed_payment_key_arg: number): bigint {
37540 if(!isWasmInitialized) {
37541 throw new Error("initializeWasm() must be awaited first!");
37543 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);
37544 return nativeResponseValue;
37546 // bool TxCreationKeys_eq(const struct LDKTxCreationKeys *NONNULL_PTR a, const struct LDKTxCreationKeys *NONNULL_PTR b);
37548 export function TxCreationKeys_eq(a: bigint, b: bigint): boolean {
37549 if(!isWasmInitialized) {
37550 throw new Error("initializeWasm() must be awaited first!");
37552 const nativeResponseValue = wasm.TS_TxCreationKeys_eq(a, b);
37553 return nativeResponseValue;
37555 // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
37557 export function TxCreationKeys_clone_ptr(arg: bigint): bigint {
37558 if(!isWasmInitialized) {
37559 throw new Error("initializeWasm() must be awaited first!");
37561 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
37562 return nativeResponseValue;
37564 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
37566 export function TxCreationKeys_clone(orig: bigint): bigint {
37567 if(!isWasmInitialized) {
37568 throw new Error("initializeWasm() must be awaited first!");
37570 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
37571 return nativeResponseValue;
37573 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
37575 export function TxCreationKeys_write(obj: bigint): number {
37576 if(!isWasmInitialized) {
37577 throw new Error("initializeWasm() must be awaited first!");
37579 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
37580 return nativeResponseValue;
37582 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
37584 export function TxCreationKeys_read(ser: number): bigint {
37585 if(!isWasmInitialized) {
37586 throw new Error("initializeWasm() must be awaited first!");
37588 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
37589 return nativeResponseValue;
37591 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
37593 export function ChannelPublicKeys_free(this_obj: bigint): void {
37594 if(!isWasmInitialized) {
37595 throw new Error("initializeWasm() must be awaited first!");
37597 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
37598 // debug statements here
37600 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
37602 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: bigint): number {
37603 if(!isWasmInitialized) {
37604 throw new Error("initializeWasm() must be awaited first!");
37606 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
37607 return nativeResponseValue;
37609 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37611 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: bigint, val: number): void {
37612 if(!isWasmInitialized) {
37613 throw new Error("initializeWasm() must be awaited first!");
37615 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
37616 // debug statements here
37618 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
37620 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: bigint): number {
37621 if(!isWasmInitialized) {
37622 throw new Error("initializeWasm() must be awaited first!");
37624 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
37625 return nativeResponseValue;
37627 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37629 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: bigint, val: number): void {
37630 if(!isWasmInitialized) {
37631 throw new Error("initializeWasm() must be awaited first!");
37633 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
37634 // debug statements here
37636 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
37638 export function ChannelPublicKeys_get_payment_point(this_ptr: bigint): number {
37639 if(!isWasmInitialized) {
37640 throw new Error("initializeWasm() must be awaited first!");
37642 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
37643 return nativeResponseValue;
37645 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37647 export function ChannelPublicKeys_set_payment_point(this_ptr: bigint, val: number): void {
37648 if(!isWasmInitialized) {
37649 throw new Error("initializeWasm() must be awaited first!");
37651 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
37652 // debug statements here
37654 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
37656 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: bigint): number {
37657 if(!isWasmInitialized) {
37658 throw new Error("initializeWasm() must be awaited first!");
37660 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
37661 return nativeResponseValue;
37663 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37665 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
37666 if(!isWasmInitialized) {
37667 throw new Error("initializeWasm() must be awaited first!");
37669 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
37670 // debug statements here
37672 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
37674 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: bigint): number {
37675 if(!isWasmInitialized) {
37676 throw new Error("initializeWasm() must be awaited first!");
37678 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
37679 return nativeResponseValue;
37681 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37683 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: bigint, val: number): void {
37684 if(!isWasmInitialized) {
37685 throw new Error("initializeWasm() must be awaited first!");
37687 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
37688 // debug statements here
37690 // MUST_USE_RES struct LDKChannelPublicKeys ChannelPublicKeys_new(struct LDKPublicKey funding_pubkey_arg, struct LDKPublicKey revocation_basepoint_arg, struct LDKPublicKey payment_point_arg, struct LDKPublicKey delayed_payment_basepoint_arg, struct LDKPublicKey htlc_basepoint_arg);
37692 export function ChannelPublicKeys_new(funding_pubkey_arg: number, revocation_basepoint_arg: number, payment_point_arg: number, delayed_payment_basepoint_arg: number, htlc_basepoint_arg: number): bigint {
37693 if(!isWasmInitialized) {
37694 throw new Error("initializeWasm() must be awaited first!");
37696 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
37697 return nativeResponseValue;
37699 // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
37701 export function ChannelPublicKeys_clone_ptr(arg: bigint): bigint {
37702 if(!isWasmInitialized) {
37703 throw new Error("initializeWasm() must be awaited first!");
37705 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
37706 return nativeResponseValue;
37708 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
37710 export function ChannelPublicKeys_clone(orig: bigint): bigint {
37711 if(!isWasmInitialized) {
37712 throw new Error("initializeWasm() must be awaited first!");
37714 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
37715 return nativeResponseValue;
37717 // uint64_t ChannelPublicKeys_hash(const struct LDKChannelPublicKeys *NONNULL_PTR o);
37719 export function ChannelPublicKeys_hash(o: bigint): bigint {
37720 if(!isWasmInitialized) {
37721 throw new Error("initializeWasm() must be awaited first!");
37723 const nativeResponseValue = wasm.TS_ChannelPublicKeys_hash(o);
37724 return nativeResponseValue;
37726 // bool ChannelPublicKeys_eq(const struct LDKChannelPublicKeys *NONNULL_PTR a, const struct LDKChannelPublicKeys *NONNULL_PTR b);
37728 export function ChannelPublicKeys_eq(a: bigint, b: bigint): boolean {
37729 if(!isWasmInitialized) {
37730 throw new Error("initializeWasm() must be awaited first!");
37732 const nativeResponseValue = wasm.TS_ChannelPublicKeys_eq(a, b);
37733 return nativeResponseValue;
37735 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
37737 export function ChannelPublicKeys_write(obj: bigint): number {
37738 if(!isWasmInitialized) {
37739 throw new Error("initializeWasm() must be awaited first!");
37741 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
37742 return nativeResponseValue;
37744 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
37746 export function ChannelPublicKeys_read(ser: number): bigint {
37747 if(!isWasmInitialized) {
37748 throw new Error("initializeWasm() must be awaited first!");
37750 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
37751 return nativeResponseValue;
37753 // MUST_USE_RES struct LDKTxCreationKeys TxCreationKeys_derive_new(struct LDKPublicKey per_commitment_point, struct LDKPublicKey broadcaster_delayed_payment_base, struct LDKPublicKey broadcaster_htlc_base, struct LDKPublicKey countersignatory_revocation_base, struct LDKPublicKey countersignatory_htlc_base);
37755 export function TxCreationKeys_derive_new(per_commitment_point: number, broadcaster_delayed_payment_base: number, broadcaster_htlc_base: number, countersignatory_revocation_base: number, countersignatory_htlc_base: number): bigint {
37756 if(!isWasmInitialized) {
37757 throw new Error("initializeWasm() must be awaited first!");
37759 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
37760 return nativeResponseValue;
37762 // 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);
37764 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
37765 if(!isWasmInitialized) {
37766 throw new Error("initializeWasm() must be awaited first!");
37768 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
37769 return nativeResponseValue;
37771 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
37773 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
37774 if(!isWasmInitialized) {
37775 throw new Error("initializeWasm() must be awaited first!");
37777 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
37778 return nativeResponseValue;
37780 // struct LDKCVec_u8Z get_counterparty_payment_script(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features, struct LDKPublicKey payment_key);
37782 export function get_counterparty_payment_script(channel_type_features: bigint, payment_key: number): number {
37783 if(!isWasmInitialized) {
37784 throw new Error("initializeWasm() must be awaited first!");
37786 const nativeResponseValue = wasm.TS_get_counterparty_payment_script(channel_type_features, payment_key);
37787 return nativeResponseValue;
37789 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
37791 export function HTLCOutputInCommitment_free(this_obj: bigint): void {
37792 if(!isWasmInitialized) {
37793 throw new Error("initializeWasm() must be awaited first!");
37795 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
37796 // debug statements here
37798 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
37800 export function HTLCOutputInCommitment_get_offered(this_ptr: bigint): boolean {
37801 if(!isWasmInitialized) {
37802 throw new Error("initializeWasm() must be awaited first!");
37804 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
37805 return nativeResponseValue;
37807 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
37809 export function HTLCOutputInCommitment_set_offered(this_ptr: bigint, val: boolean): void {
37810 if(!isWasmInitialized) {
37811 throw new Error("initializeWasm() must be awaited first!");
37813 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
37814 // debug statements here
37816 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
37818 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: bigint): bigint {
37819 if(!isWasmInitialized) {
37820 throw new Error("initializeWasm() must be awaited first!");
37822 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
37823 return nativeResponseValue;
37825 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
37827 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: bigint, val: bigint): void {
37828 if(!isWasmInitialized) {
37829 throw new Error("initializeWasm() must be awaited first!");
37831 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
37832 // debug statements here
37834 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
37836 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: bigint): number {
37837 if(!isWasmInitialized) {
37838 throw new Error("initializeWasm() must be awaited first!");
37840 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
37841 return nativeResponseValue;
37843 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
37845 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: bigint, val: number): void {
37846 if(!isWasmInitialized) {
37847 throw new Error("initializeWasm() must be awaited first!");
37849 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
37850 // debug statements here
37852 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
37854 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: bigint): number {
37855 if(!isWasmInitialized) {
37856 throw new Error("initializeWasm() must be awaited first!");
37858 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
37859 return nativeResponseValue;
37861 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37863 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: bigint, val: number): void {
37864 if(!isWasmInitialized) {
37865 throw new Error("initializeWasm() must be awaited first!");
37867 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
37868 // debug statements here
37870 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
37872 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: bigint): bigint {
37873 if(!isWasmInitialized) {
37874 throw new Error("initializeWasm() must be awaited first!");
37876 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
37877 return nativeResponseValue;
37879 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
37881 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: bigint, val: bigint): void {
37882 if(!isWasmInitialized) {
37883 throw new Error("initializeWasm() must be awaited first!");
37885 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
37886 // debug statements here
37888 // 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);
37890 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 {
37891 if(!isWasmInitialized) {
37892 throw new Error("initializeWasm() must be awaited first!");
37894 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
37895 return nativeResponseValue;
37897 // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
37899 export function HTLCOutputInCommitment_clone_ptr(arg: bigint): bigint {
37900 if(!isWasmInitialized) {
37901 throw new Error("initializeWasm() must be awaited first!");
37903 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
37904 return nativeResponseValue;
37906 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
37908 export function HTLCOutputInCommitment_clone(orig: bigint): bigint {
37909 if(!isWasmInitialized) {
37910 throw new Error("initializeWasm() must be awaited first!");
37912 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
37913 return nativeResponseValue;
37915 // bool HTLCOutputInCommitment_eq(const struct LDKHTLCOutputInCommitment *NONNULL_PTR a, const struct LDKHTLCOutputInCommitment *NONNULL_PTR b);
37917 export function HTLCOutputInCommitment_eq(a: bigint, b: bigint): boolean {
37918 if(!isWasmInitialized) {
37919 throw new Error("initializeWasm() must be awaited first!");
37921 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_eq(a, b);
37922 return nativeResponseValue;
37924 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
37926 export function HTLCOutputInCommitment_write(obj: bigint): number {
37927 if(!isWasmInitialized) {
37928 throw new Error("initializeWasm() must be awaited first!");
37930 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
37931 return nativeResponseValue;
37933 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
37935 export function HTLCOutputInCommitment_read(ser: number): bigint {
37936 if(!isWasmInitialized) {
37937 throw new Error("initializeWasm() must be awaited first!");
37939 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
37940 return nativeResponseValue;
37942 // 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);
37944 export function get_htlc_redeemscript(htlc: bigint, channel_type_features: bigint, keys: bigint): number {
37945 if(!isWasmInitialized) {
37946 throw new Error("initializeWasm() must be awaited first!");
37948 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, channel_type_features, keys);
37949 return nativeResponseValue;
37951 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
37953 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
37954 if(!isWasmInitialized) {
37955 throw new Error("initializeWasm() must be awaited first!");
37957 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
37958 return nativeResponseValue;
37960 // 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, struct LDKPublicKey broadcaster_delayed_payment_key, struct LDKPublicKey revocation_key);
37962 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: number, revocation_key: number): number {
37963 if(!isWasmInitialized) {
37964 throw new Error("initializeWasm() must be awaited first!");
37966 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, channel_type_features, broadcaster_delayed_payment_key, revocation_key);
37967 return nativeResponseValue;
37969 // 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);
37971 export function build_htlc_input_witness(local_sig: number, remote_sig: number, preimage: bigint, redeem_script: number, channel_type_features: bigint): number {
37972 if(!isWasmInitialized) {
37973 throw new Error("initializeWasm() must be awaited first!");
37975 const nativeResponseValue = wasm.TS_build_htlc_input_witness(local_sig, remote_sig, preimage, redeem_script, channel_type_features);
37976 return nativeResponseValue;
37978 // struct LDKCVec_u8Z get_to_countersignatory_with_anchors_redeemscript(struct LDKPublicKey payment_point);
37980 export function get_to_countersignatory_with_anchors_redeemscript(payment_point: number): number {
37981 if(!isWasmInitialized) {
37982 throw new Error("initializeWasm() must be awaited first!");
37984 const nativeResponseValue = wasm.TS_get_to_countersignatory_with_anchors_redeemscript(payment_point);
37985 return nativeResponseValue;
37987 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
37989 export function get_anchor_redeemscript(funding_pubkey: number): number {
37990 if(!isWasmInitialized) {
37991 throw new Error("initializeWasm() must be awaited first!");
37993 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
37994 return nativeResponseValue;
37996 // struct LDKWitness build_anchor_input_witness(struct LDKPublicKey funding_key, struct LDKECDSASignature funding_sig);
37998 export function build_anchor_input_witness(funding_key: number, funding_sig: number): number {
37999 if(!isWasmInitialized) {
38000 throw new Error("initializeWasm() must be awaited first!");
38002 const nativeResponseValue = wasm.TS_build_anchor_input_witness(funding_key, funding_sig);
38003 return nativeResponseValue;
38005 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
38007 export function ChannelTransactionParameters_free(this_obj: bigint): void {
38008 if(!isWasmInitialized) {
38009 throw new Error("initializeWasm() must be awaited first!");
38011 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
38012 // debug statements here
38014 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
38016 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: bigint): bigint {
38017 if(!isWasmInitialized) {
38018 throw new Error("initializeWasm() must be awaited first!");
38020 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
38021 return nativeResponseValue;
38023 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
38025 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: bigint, val: bigint): void {
38026 if(!isWasmInitialized) {
38027 throw new Error("initializeWasm() must be awaited first!");
38029 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
38030 // debug statements here
38032 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
38034 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: bigint): number {
38035 if(!isWasmInitialized) {
38036 throw new Error("initializeWasm() must be awaited first!");
38038 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
38039 return nativeResponseValue;
38041 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
38043 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: bigint, val: number): void {
38044 if(!isWasmInitialized) {
38045 throw new Error("initializeWasm() must be awaited first!");
38047 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
38048 // debug statements here
38050 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
38052 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: bigint): boolean {
38053 if(!isWasmInitialized) {
38054 throw new Error("initializeWasm() must be awaited first!");
38056 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
38057 return nativeResponseValue;
38059 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
38061 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: bigint, val: boolean): void {
38062 if(!isWasmInitialized) {
38063 throw new Error("initializeWasm() must be awaited first!");
38065 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
38066 // debug statements here
38068 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
38070 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: bigint): bigint {
38071 if(!isWasmInitialized) {
38072 throw new Error("initializeWasm() must be awaited first!");
38074 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
38075 return nativeResponseValue;
38077 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
38079 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: bigint, val: bigint): void {
38080 if(!isWasmInitialized) {
38081 throw new Error("initializeWasm() must be awaited first!");
38083 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
38084 // debug statements here
38086 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
38088 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: bigint): bigint {
38089 if(!isWasmInitialized) {
38090 throw new Error("initializeWasm() must be awaited first!");
38092 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
38093 return nativeResponseValue;
38095 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
38097 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: bigint, val: bigint): void {
38098 if(!isWasmInitialized) {
38099 throw new Error("initializeWasm() must be awaited first!");
38101 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
38102 // debug statements here
38104 // struct LDKChannelTypeFeatures ChannelTransactionParameters_get_channel_type_features(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
38106 export function ChannelTransactionParameters_get_channel_type_features(this_ptr: bigint): bigint {
38107 if(!isWasmInitialized) {
38108 throw new Error("initializeWasm() must be awaited first!");
38110 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_channel_type_features(this_ptr);
38111 return nativeResponseValue;
38113 // void ChannelTransactionParameters_set_channel_type_features(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
38115 export function ChannelTransactionParameters_set_channel_type_features(this_ptr: bigint, val: bigint): void {
38116 if(!isWasmInitialized) {
38117 throw new Error("initializeWasm() must be awaited first!");
38119 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_channel_type_features(this_ptr, val);
38120 // debug statements here
38122 // 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);
38124 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 {
38125 if(!isWasmInitialized) {
38126 throw new Error("initializeWasm() must be awaited first!");
38128 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);
38129 return nativeResponseValue;
38131 // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
38133 export function ChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
38134 if(!isWasmInitialized) {
38135 throw new Error("initializeWasm() must be awaited first!");
38137 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
38138 return nativeResponseValue;
38140 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
38142 export function ChannelTransactionParameters_clone(orig: bigint): bigint {
38143 if(!isWasmInitialized) {
38144 throw new Error("initializeWasm() must be awaited first!");
38146 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
38147 return nativeResponseValue;
38149 // uint64_t ChannelTransactionParameters_hash(const struct LDKChannelTransactionParameters *NONNULL_PTR o);
38151 export function ChannelTransactionParameters_hash(o: bigint): bigint {
38152 if(!isWasmInitialized) {
38153 throw new Error("initializeWasm() must be awaited first!");
38155 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_hash(o);
38156 return nativeResponseValue;
38158 // bool ChannelTransactionParameters_eq(const struct LDKChannelTransactionParameters *NONNULL_PTR a, const struct LDKChannelTransactionParameters *NONNULL_PTR b);
38160 export function ChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
38161 if(!isWasmInitialized) {
38162 throw new Error("initializeWasm() must be awaited first!");
38164 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_eq(a, b);
38165 return nativeResponseValue;
38167 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
38169 export function CounterpartyChannelTransactionParameters_free(this_obj: bigint): void {
38170 if(!isWasmInitialized) {
38171 throw new Error("initializeWasm() must be awaited first!");
38173 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
38174 // debug statements here
38176 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
38178 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: bigint): bigint {
38179 if(!isWasmInitialized) {
38180 throw new Error("initializeWasm() must be awaited first!");
38182 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
38183 return nativeResponseValue;
38185 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
38187 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: bigint, val: bigint): void {
38188 if(!isWasmInitialized) {
38189 throw new Error("initializeWasm() must be awaited first!");
38191 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
38192 // debug statements here
38194 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
38196 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: bigint): number {
38197 if(!isWasmInitialized) {
38198 throw new Error("initializeWasm() must be awaited first!");
38200 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
38201 return nativeResponseValue;
38203 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
38205 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: bigint, val: number): void {
38206 if(!isWasmInitialized) {
38207 throw new Error("initializeWasm() must be awaited first!");
38209 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
38210 // debug statements here
38212 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
38214 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: bigint, selected_contest_delay_arg: number): bigint {
38215 if(!isWasmInitialized) {
38216 throw new Error("initializeWasm() must be awaited first!");
38218 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
38219 return nativeResponseValue;
38221 // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
38223 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
38224 if(!isWasmInitialized) {
38225 throw new Error("initializeWasm() must be awaited first!");
38227 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
38228 return nativeResponseValue;
38230 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
38232 export function CounterpartyChannelTransactionParameters_clone(orig: bigint): bigint {
38233 if(!isWasmInitialized) {
38234 throw new Error("initializeWasm() must be awaited first!");
38236 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
38237 return nativeResponseValue;
38239 // uint64_t CounterpartyChannelTransactionParameters_hash(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR o);
38241 export function CounterpartyChannelTransactionParameters_hash(o: bigint): bigint {
38242 if(!isWasmInitialized) {
38243 throw new Error("initializeWasm() must be awaited first!");
38245 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_hash(o);
38246 return nativeResponseValue;
38248 // bool CounterpartyChannelTransactionParameters_eq(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR a, const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR b);
38250 export function CounterpartyChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
38251 if(!isWasmInitialized) {
38252 throw new Error("initializeWasm() must be awaited first!");
38254 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_eq(a, b);
38255 return nativeResponseValue;
38257 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
38259 export function ChannelTransactionParameters_is_populated(this_arg: bigint): boolean {
38260 if(!isWasmInitialized) {
38261 throw new Error("initializeWasm() must be awaited first!");
38263 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
38264 return nativeResponseValue;
38266 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
38268 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: bigint): bigint {
38269 if(!isWasmInitialized) {
38270 throw new Error("initializeWasm() must be awaited first!");
38272 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
38273 return nativeResponseValue;
38275 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
38277 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: bigint): bigint {
38278 if(!isWasmInitialized) {
38279 throw new Error("initializeWasm() must be awaited first!");
38281 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
38282 return nativeResponseValue;
38284 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
38286 export function CounterpartyChannelTransactionParameters_write(obj: bigint): number {
38287 if(!isWasmInitialized) {
38288 throw new Error("initializeWasm() must be awaited first!");
38290 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
38291 return nativeResponseValue;
38293 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
38295 export function CounterpartyChannelTransactionParameters_read(ser: number): bigint {
38296 if(!isWasmInitialized) {
38297 throw new Error("initializeWasm() must be awaited first!");
38299 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
38300 return nativeResponseValue;
38302 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
38304 export function ChannelTransactionParameters_write(obj: bigint): number {
38305 if(!isWasmInitialized) {
38306 throw new Error("initializeWasm() must be awaited first!");
38308 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
38309 return nativeResponseValue;
38311 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
38313 export function ChannelTransactionParameters_read(ser: number): bigint {
38314 if(!isWasmInitialized) {
38315 throw new Error("initializeWasm() must be awaited first!");
38317 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
38318 return nativeResponseValue;
38320 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
38322 export function DirectedChannelTransactionParameters_free(this_obj: bigint): void {
38323 if(!isWasmInitialized) {
38324 throw new Error("initializeWasm() must be awaited first!");
38326 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
38327 // debug statements here
38329 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
38331 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: bigint): bigint {
38332 if(!isWasmInitialized) {
38333 throw new Error("initializeWasm() must be awaited first!");
38335 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
38336 return nativeResponseValue;
38338 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
38340 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: bigint): bigint {
38341 if(!isWasmInitialized) {
38342 throw new Error("initializeWasm() must be awaited first!");
38344 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
38345 return nativeResponseValue;
38347 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
38349 export function DirectedChannelTransactionParameters_contest_delay(this_arg: bigint): number {
38350 if(!isWasmInitialized) {
38351 throw new Error("initializeWasm() must be awaited first!");
38353 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
38354 return nativeResponseValue;
38356 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
38358 export function DirectedChannelTransactionParameters_is_outbound(this_arg: bigint): boolean {
38359 if(!isWasmInitialized) {
38360 throw new Error("initializeWasm() must be awaited first!");
38362 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
38363 return nativeResponseValue;
38365 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
38367 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: bigint): bigint {
38368 if(!isWasmInitialized) {
38369 throw new Error("initializeWasm() must be awaited first!");
38371 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
38372 return nativeResponseValue;
38374 // MUST_USE_RES struct LDKChannelTypeFeatures DirectedChannelTransactionParameters_channel_type_features(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
38376 export function DirectedChannelTransactionParameters_channel_type_features(this_arg: bigint): bigint {
38377 if(!isWasmInitialized) {
38378 throw new Error("initializeWasm() must be awaited first!");
38380 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_channel_type_features(this_arg);
38381 return nativeResponseValue;
38383 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
38385 export function HolderCommitmentTransaction_free(this_obj: bigint): void {
38386 if(!isWasmInitialized) {
38387 throw new Error("initializeWasm() must be awaited first!");
38389 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
38390 // debug statements here
38392 // struct LDKECDSASignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
38394 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: bigint): number {
38395 if(!isWasmInitialized) {
38396 throw new Error("initializeWasm() must be awaited first!");
38398 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
38399 return nativeResponseValue;
38401 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
38403 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: bigint, val: number): void {
38404 if(!isWasmInitialized) {
38405 throw new Error("initializeWasm() must be awaited first!");
38407 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
38408 // debug statements here
38410 // struct LDKCVec_ECDSASignatureZ HolderCommitmentTransaction_get_counterparty_htlc_sigs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
38412 export function HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr: bigint): number {
38413 if(!isWasmInitialized) {
38414 throw new Error("initializeWasm() must be awaited first!");
38416 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr);
38417 return nativeResponseValue;
38419 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_ECDSASignatureZ val);
38421 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: bigint, val: number): void {
38422 if(!isWasmInitialized) {
38423 throw new Error("initializeWasm() must be awaited first!");
38425 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
38426 // debug statements here
38428 // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
38430 export function HolderCommitmentTransaction_clone_ptr(arg: bigint): bigint {
38431 if(!isWasmInitialized) {
38432 throw new Error("initializeWasm() must be awaited first!");
38434 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
38435 return nativeResponseValue;
38437 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
38439 export function HolderCommitmentTransaction_clone(orig: bigint): bigint {
38440 if(!isWasmInitialized) {
38441 throw new Error("initializeWasm() must be awaited first!");
38443 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
38444 return nativeResponseValue;
38446 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
38448 export function HolderCommitmentTransaction_write(obj: bigint): number {
38449 if(!isWasmInitialized) {
38450 throw new Error("initializeWasm() must be awaited first!");
38452 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
38453 return nativeResponseValue;
38455 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
38457 export function HolderCommitmentTransaction_read(ser: number): bigint {
38458 if(!isWasmInitialized) {
38459 throw new Error("initializeWasm() must be awaited first!");
38461 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
38462 return nativeResponseValue;
38464 // 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);
38466 export function HolderCommitmentTransaction_new(commitment_tx: bigint, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): bigint {
38467 if(!isWasmInitialized) {
38468 throw new Error("initializeWasm() must be awaited first!");
38470 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
38471 return nativeResponseValue;
38473 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
38475 export function BuiltCommitmentTransaction_free(this_obj: bigint): void {
38476 if(!isWasmInitialized) {
38477 throw new Error("initializeWasm() must be awaited first!");
38479 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
38480 // debug statements here
38482 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
38484 export function BuiltCommitmentTransaction_get_transaction(this_ptr: bigint): number {
38485 if(!isWasmInitialized) {
38486 throw new Error("initializeWasm() must be awaited first!");
38488 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
38489 return nativeResponseValue;
38491 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
38493 export function BuiltCommitmentTransaction_set_transaction(this_ptr: bigint, val: number): void {
38494 if(!isWasmInitialized) {
38495 throw new Error("initializeWasm() must be awaited first!");
38497 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
38498 // debug statements here
38500 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
38502 export function BuiltCommitmentTransaction_get_txid(this_ptr: bigint): number {
38503 if(!isWasmInitialized) {
38504 throw new Error("initializeWasm() must be awaited first!");
38506 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
38507 return nativeResponseValue;
38509 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
38511 export function BuiltCommitmentTransaction_set_txid(this_ptr: bigint, val: number): void {
38512 if(!isWasmInitialized) {
38513 throw new Error("initializeWasm() must be awaited first!");
38515 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
38516 // debug statements here
38518 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
38520 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): bigint {
38521 if(!isWasmInitialized) {
38522 throw new Error("initializeWasm() must be awaited first!");
38524 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
38525 return nativeResponseValue;
38527 // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
38529 export function BuiltCommitmentTransaction_clone_ptr(arg: bigint): bigint {
38530 if(!isWasmInitialized) {
38531 throw new Error("initializeWasm() must be awaited first!");
38533 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
38534 return nativeResponseValue;
38536 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
38538 export function BuiltCommitmentTransaction_clone(orig: bigint): bigint {
38539 if(!isWasmInitialized) {
38540 throw new Error("initializeWasm() must be awaited first!");
38542 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
38543 return nativeResponseValue;
38545 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
38547 export function BuiltCommitmentTransaction_write(obj: bigint): number {
38548 if(!isWasmInitialized) {
38549 throw new Error("initializeWasm() must be awaited first!");
38551 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
38552 return nativeResponseValue;
38554 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
38556 export function BuiltCommitmentTransaction_read(ser: number): bigint {
38557 if(!isWasmInitialized) {
38558 throw new Error("initializeWasm() must be awaited first!");
38560 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
38561 return nativeResponseValue;
38563 // 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);
38565 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
38566 if(!isWasmInitialized) {
38567 throw new Error("initializeWasm() must be awaited first!");
38569 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
38570 return nativeResponseValue;
38572 // 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);
38574 export function BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
38575 if(!isWasmInitialized) {
38576 throw new Error("initializeWasm() must be awaited first!");
38578 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
38579 return nativeResponseValue;
38581 // 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);
38583 export function BuiltCommitmentTransaction_sign_holder_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint, entropy_source: bigint): number {
38584 if(!isWasmInitialized) {
38585 throw new Error("initializeWasm() must be awaited first!");
38587 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_holder_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis, entropy_source);
38588 return nativeResponseValue;
38590 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
38592 export function ClosingTransaction_free(this_obj: bigint): void {
38593 if(!isWasmInitialized) {
38594 throw new Error("initializeWasm() must be awaited first!");
38596 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
38597 // debug statements here
38599 // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
38601 export function ClosingTransaction_clone_ptr(arg: bigint): bigint {
38602 if(!isWasmInitialized) {
38603 throw new Error("initializeWasm() must be awaited first!");
38605 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
38606 return nativeResponseValue;
38608 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
38610 export function ClosingTransaction_clone(orig: bigint): bigint {
38611 if(!isWasmInitialized) {
38612 throw new Error("initializeWasm() must be awaited first!");
38614 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
38615 return nativeResponseValue;
38617 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
38619 export function ClosingTransaction_hash(o: bigint): bigint {
38620 if(!isWasmInitialized) {
38621 throw new Error("initializeWasm() must be awaited first!");
38623 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
38624 return nativeResponseValue;
38626 // bool ClosingTransaction_eq(const struct LDKClosingTransaction *NONNULL_PTR a, const struct LDKClosingTransaction *NONNULL_PTR b);
38628 export function ClosingTransaction_eq(a: bigint, b: bigint): boolean {
38629 if(!isWasmInitialized) {
38630 throw new Error("initializeWasm() must be awaited first!");
38632 const nativeResponseValue = wasm.TS_ClosingTransaction_eq(a, b);
38633 return nativeResponseValue;
38635 // 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);
38637 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 {
38638 if(!isWasmInitialized) {
38639 throw new Error("initializeWasm() must be awaited first!");
38641 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
38642 return nativeResponseValue;
38644 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
38646 export function ClosingTransaction_trust(this_arg: bigint): bigint {
38647 if(!isWasmInitialized) {
38648 throw new Error("initializeWasm() must be awaited first!");
38650 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
38651 return nativeResponseValue;
38653 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
38655 export function ClosingTransaction_verify(this_arg: bigint, funding_outpoint: bigint): bigint {
38656 if(!isWasmInitialized) {
38657 throw new Error("initializeWasm() must be awaited first!");
38659 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
38660 return nativeResponseValue;
38662 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
38664 export function ClosingTransaction_to_holder_value_sat(this_arg: bigint): bigint {
38665 if(!isWasmInitialized) {
38666 throw new Error("initializeWasm() must be awaited first!");
38668 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
38669 return nativeResponseValue;
38671 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
38673 export function ClosingTransaction_to_counterparty_value_sat(this_arg: bigint): bigint {
38674 if(!isWasmInitialized) {
38675 throw new Error("initializeWasm() must be awaited first!");
38677 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
38678 return nativeResponseValue;
38680 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
38682 export function ClosingTransaction_to_holder_script(this_arg: bigint): number {
38683 if(!isWasmInitialized) {
38684 throw new Error("initializeWasm() must be awaited first!");
38686 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
38687 return nativeResponseValue;
38689 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
38691 export function ClosingTransaction_to_counterparty_script(this_arg: bigint): number {
38692 if(!isWasmInitialized) {
38693 throw new Error("initializeWasm() must be awaited first!");
38695 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
38696 return nativeResponseValue;
38698 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
38700 export function TrustedClosingTransaction_free(this_obj: bigint): void {
38701 if(!isWasmInitialized) {
38702 throw new Error("initializeWasm() must be awaited first!");
38704 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
38705 // debug statements here
38707 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
38709 export function TrustedClosingTransaction_built_transaction(this_arg: bigint): number {
38710 if(!isWasmInitialized) {
38711 throw new Error("initializeWasm() must be awaited first!");
38713 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
38714 return nativeResponseValue;
38716 // 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);
38718 export function TrustedClosingTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
38719 if(!isWasmInitialized) {
38720 throw new Error("initializeWasm() must be awaited first!");
38722 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
38723 return nativeResponseValue;
38725 // 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);
38727 export function TrustedClosingTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
38728 if(!isWasmInitialized) {
38729 throw new Error("initializeWasm() must be awaited first!");
38731 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
38732 return nativeResponseValue;
38734 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
38736 export function CommitmentTransaction_free(this_obj: bigint): void {
38737 if(!isWasmInitialized) {
38738 throw new Error("initializeWasm() must be awaited first!");
38740 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
38741 // debug statements here
38743 // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
38745 export function CommitmentTransaction_clone_ptr(arg: bigint): bigint {
38746 if(!isWasmInitialized) {
38747 throw new Error("initializeWasm() must be awaited first!");
38749 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
38750 return nativeResponseValue;
38752 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
38754 export function CommitmentTransaction_clone(orig: bigint): bigint {
38755 if(!isWasmInitialized) {
38756 throw new Error("initializeWasm() must be awaited first!");
38758 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
38759 return nativeResponseValue;
38761 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
38763 export function CommitmentTransaction_write(obj: bigint): number {
38764 if(!isWasmInitialized) {
38765 throw new Error("initializeWasm() must be awaited first!");
38767 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
38768 return nativeResponseValue;
38770 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
38772 export function CommitmentTransaction_read(ser: number): bigint {
38773 if(!isWasmInitialized) {
38774 throw new Error("initializeWasm() must be awaited first!");
38776 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
38777 return nativeResponseValue;
38779 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
38781 export function CommitmentTransaction_commitment_number(this_arg: bigint): bigint {
38782 if(!isWasmInitialized) {
38783 throw new Error("initializeWasm() must be awaited first!");
38785 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
38786 return nativeResponseValue;
38788 // MUST_USE_RES struct LDKPublicKey CommitmentTransaction_per_commitment_point(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
38790 export function CommitmentTransaction_per_commitment_point(this_arg: bigint): number {
38791 if(!isWasmInitialized) {
38792 throw new Error("initializeWasm() must be awaited first!");
38794 const nativeResponseValue = wasm.TS_CommitmentTransaction_per_commitment_point(this_arg);
38795 return nativeResponseValue;
38797 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
38799 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: bigint): bigint {
38800 if(!isWasmInitialized) {
38801 throw new Error("initializeWasm() must be awaited first!");
38803 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
38804 return nativeResponseValue;
38806 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
38808 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: bigint): bigint {
38809 if(!isWasmInitialized) {
38810 throw new Error("initializeWasm() must be awaited first!");
38812 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
38813 return nativeResponseValue;
38815 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
38817 export function CommitmentTransaction_feerate_per_kw(this_arg: bigint): number {
38818 if(!isWasmInitialized) {
38819 throw new Error("initializeWasm() must be awaited first!");
38821 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
38822 return nativeResponseValue;
38824 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
38826 export function CommitmentTransaction_trust(this_arg: bigint): bigint {
38827 if(!isWasmInitialized) {
38828 throw new Error("initializeWasm() must be awaited first!");
38830 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
38831 return nativeResponseValue;
38833 // 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);
38835 export function CommitmentTransaction_verify(this_arg: bigint, channel_parameters: bigint, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
38836 if(!isWasmInitialized) {
38837 throw new Error("initializeWasm() must be awaited first!");
38839 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
38840 return nativeResponseValue;
38842 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
38844 export function TrustedCommitmentTransaction_free(this_obj: bigint): void {
38845 if(!isWasmInitialized) {
38846 throw new Error("initializeWasm() must be awaited first!");
38848 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
38849 // debug statements here
38851 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
38853 export function TrustedCommitmentTransaction_txid(this_arg: bigint): number {
38854 if(!isWasmInitialized) {
38855 throw new Error("initializeWasm() must be awaited first!");
38857 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
38858 return nativeResponseValue;
38860 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
38862 export function TrustedCommitmentTransaction_built_transaction(this_arg: bigint): bigint {
38863 if(!isWasmInitialized) {
38864 throw new Error("initializeWasm() must be awaited first!");
38866 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
38867 return nativeResponseValue;
38869 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
38871 export function TrustedCommitmentTransaction_keys(this_arg: bigint): bigint {
38872 if(!isWasmInitialized) {
38873 throw new Error("initializeWasm() must be awaited first!");
38875 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
38876 return nativeResponseValue;
38878 // MUST_USE_RES struct LDKChannelTypeFeatures TrustedCommitmentTransaction_channel_type_features(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
38880 export function TrustedCommitmentTransaction_channel_type_features(this_arg: bigint): bigint {
38881 if(!isWasmInitialized) {
38882 throw new Error("initializeWasm() must be awaited first!");
38884 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_channel_type_features(this_arg);
38885 return nativeResponseValue;
38887 // 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);
38889 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint, entropy_source: bigint): bigint {
38890 if(!isWasmInitialized) {
38891 throw new Error("initializeWasm() must be awaited first!");
38893 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters, entropy_source);
38894 return nativeResponseValue;
38896 // MUST_USE_RES struct LDKCOption_usizeZ TrustedCommitmentTransaction_revokeable_output_index(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
38898 export function TrustedCommitmentTransaction_revokeable_output_index(this_arg: bigint): bigint {
38899 if(!isWasmInitialized) {
38900 throw new Error("initializeWasm() must be awaited first!");
38902 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_revokeable_output_index(this_arg);
38903 return nativeResponseValue;
38905 // 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);
38907 export function TrustedCommitmentTransaction_build_to_local_justice_tx(this_arg: bigint, feerate_per_kw: bigint, destination_script: number): bigint {
38908 if(!isWasmInitialized) {
38909 throw new Error("initializeWasm() must be awaited first!");
38911 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_build_to_local_justice_tx(this_arg, feerate_per_kw, destination_script);
38912 return nativeResponseValue;
38914 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
38916 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
38917 if(!isWasmInitialized) {
38918 throw new Error("initializeWasm() must be awaited first!");
38920 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
38921 return nativeResponseValue;
38923 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
38925 export function InitFeatures_eq(a: bigint, b: bigint): boolean {
38926 if(!isWasmInitialized) {
38927 throw new Error("initializeWasm() must be awaited first!");
38929 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
38930 return nativeResponseValue;
38932 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
38934 export function NodeFeatures_eq(a: bigint, b: bigint): boolean {
38935 if(!isWasmInitialized) {
38936 throw new Error("initializeWasm() must be awaited first!");
38938 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
38939 return nativeResponseValue;
38941 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
38943 export function ChannelFeatures_eq(a: bigint, b: bigint): boolean {
38944 if(!isWasmInitialized) {
38945 throw new Error("initializeWasm() must be awaited first!");
38947 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
38948 return nativeResponseValue;
38950 // bool Bolt11InvoiceFeatures_eq(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR a, const struct LDKBolt11InvoiceFeatures *NONNULL_PTR b);
38952 export function Bolt11InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
38953 if(!isWasmInitialized) {
38954 throw new Error("initializeWasm() must be awaited first!");
38956 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_eq(a, b);
38957 return nativeResponseValue;
38959 // bool OfferFeatures_eq(const struct LDKOfferFeatures *NONNULL_PTR a, const struct LDKOfferFeatures *NONNULL_PTR b);
38961 export function OfferFeatures_eq(a: bigint, b: bigint): boolean {
38962 if(!isWasmInitialized) {
38963 throw new Error("initializeWasm() must be awaited first!");
38965 const nativeResponseValue = wasm.TS_OfferFeatures_eq(a, b);
38966 return nativeResponseValue;
38968 // bool InvoiceRequestFeatures_eq(const struct LDKInvoiceRequestFeatures *NONNULL_PTR a, const struct LDKInvoiceRequestFeatures *NONNULL_PTR b);
38970 export function InvoiceRequestFeatures_eq(a: bigint, b: bigint): boolean {
38971 if(!isWasmInitialized) {
38972 throw new Error("initializeWasm() must be awaited first!");
38974 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_eq(a, b);
38975 return nativeResponseValue;
38977 // bool Bolt12InvoiceFeatures_eq(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR a, const struct LDKBolt12InvoiceFeatures *NONNULL_PTR b);
38979 export function Bolt12InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
38980 if(!isWasmInitialized) {
38981 throw new Error("initializeWasm() must be awaited first!");
38983 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_eq(a, b);
38984 return nativeResponseValue;
38986 // bool BlindedHopFeatures_eq(const struct LDKBlindedHopFeatures *NONNULL_PTR a, const struct LDKBlindedHopFeatures *NONNULL_PTR b);
38988 export function BlindedHopFeatures_eq(a: bigint, b: bigint): boolean {
38989 if(!isWasmInitialized) {
38990 throw new Error("initializeWasm() must be awaited first!");
38992 const nativeResponseValue = wasm.TS_BlindedHopFeatures_eq(a, b);
38993 return nativeResponseValue;
38995 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
38997 export function ChannelTypeFeatures_eq(a: bigint, b: bigint): boolean {
38998 if(!isWasmInitialized) {
38999 throw new Error("initializeWasm() must be awaited first!");
39001 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
39002 return nativeResponseValue;
39004 // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
39006 export function InitFeatures_clone_ptr(arg: bigint): bigint {
39007 if(!isWasmInitialized) {
39008 throw new Error("initializeWasm() must be awaited first!");
39010 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
39011 return nativeResponseValue;
39013 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
39015 export function InitFeatures_clone(orig: bigint): bigint {
39016 if(!isWasmInitialized) {
39017 throw new Error("initializeWasm() must be awaited first!");
39019 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
39020 return nativeResponseValue;
39022 // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
39024 export function NodeFeatures_clone_ptr(arg: bigint): bigint {
39025 if(!isWasmInitialized) {
39026 throw new Error("initializeWasm() must be awaited first!");
39028 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
39029 return nativeResponseValue;
39031 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
39033 export function NodeFeatures_clone(orig: bigint): bigint {
39034 if(!isWasmInitialized) {
39035 throw new Error("initializeWasm() must be awaited first!");
39037 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
39038 return nativeResponseValue;
39040 // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
39042 export function ChannelFeatures_clone_ptr(arg: bigint): bigint {
39043 if(!isWasmInitialized) {
39044 throw new Error("initializeWasm() must be awaited first!");
39046 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
39047 return nativeResponseValue;
39049 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
39051 export function ChannelFeatures_clone(orig: bigint): bigint {
39052 if(!isWasmInitialized) {
39053 throw new Error("initializeWasm() must be awaited first!");
39055 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
39056 return nativeResponseValue;
39058 // uint64_t Bolt11InvoiceFeatures_clone_ptr(LDKBolt11InvoiceFeatures *NONNULL_PTR arg);
39060 export function Bolt11InvoiceFeatures_clone_ptr(arg: bigint): bigint {
39061 if(!isWasmInitialized) {
39062 throw new Error("initializeWasm() must be awaited first!");
39064 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_clone_ptr(arg);
39065 return nativeResponseValue;
39067 // struct LDKBolt11InvoiceFeatures Bolt11InvoiceFeatures_clone(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR orig);
39069 export function Bolt11InvoiceFeatures_clone(orig: bigint): bigint {
39070 if(!isWasmInitialized) {
39071 throw new Error("initializeWasm() must be awaited first!");
39073 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_clone(orig);
39074 return nativeResponseValue;
39076 // uint64_t OfferFeatures_clone_ptr(LDKOfferFeatures *NONNULL_PTR arg);
39078 export function OfferFeatures_clone_ptr(arg: bigint): bigint {
39079 if(!isWasmInitialized) {
39080 throw new Error("initializeWasm() must be awaited first!");
39082 const nativeResponseValue = wasm.TS_OfferFeatures_clone_ptr(arg);
39083 return nativeResponseValue;
39085 // struct LDKOfferFeatures OfferFeatures_clone(const struct LDKOfferFeatures *NONNULL_PTR orig);
39087 export function OfferFeatures_clone(orig: bigint): bigint {
39088 if(!isWasmInitialized) {
39089 throw new Error("initializeWasm() must be awaited first!");
39091 const nativeResponseValue = wasm.TS_OfferFeatures_clone(orig);
39092 return nativeResponseValue;
39094 // uint64_t InvoiceRequestFeatures_clone_ptr(LDKInvoiceRequestFeatures *NONNULL_PTR arg);
39096 export function InvoiceRequestFeatures_clone_ptr(arg: bigint): bigint {
39097 if(!isWasmInitialized) {
39098 throw new Error("initializeWasm() must be awaited first!");
39100 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone_ptr(arg);
39101 return nativeResponseValue;
39103 // struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_clone(const struct LDKInvoiceRequestFeatures *NONNULL_PTR orig);
39105 export function InvoiceRequestFeatures_clone(orig: bigint): bigint {
39106 if(!isWasmInitialized) {
39107 throw new Error("initializeWasm() must be awaited first!");
39109 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone(orig);
39110 return nativeResponseValue;
39112 // uint64_t Bolt12InvoiceFeatures_clone_ptr(LDKBolt12InvoiceFeatures *NONNULL_PTR arg);
39114 export function Bolt12InvoiceFeatures_clone_ptr(arg: bigint): bigint {
39115 if(!isWasmInitialized) {
39116 throw new Error("initializeWasm() must be awaited first!");
39118 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone_ptr(arg);
39119 return nativeResponseValue;
39121 // struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_clone(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR orig);
39123 export function Bolt12InvoiceFeatures_clone(orig: bigint): bigint {
39124 if(!isWasmInitialized) {
39125 throw new Error("initializeWasm() must be awaited first!");
39127 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone(orig);
39128 return nativeResponseValue;
39130 // uint64_t BlindedHopFeatures_clone_ptr(LDKBlindedHopFeatures *NONNULL_PTR arg);
39132 export function BlindedHopFeatures_clone_ptr(arg: bigint): bigint {
39133 if(!isWasmInitialized) {
39134 throw new Error("initializeWasm() must be awaited first!");
39136 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone_ptr(arg);
39137 return nativeResponseValue;
39139 // struct LDKBlindedHopFeatures BlindedHopFeatures_clone(const struct LDKBlindedHopFeatures *NONNULL_PTR orig);
39141 export function BlindedHopFeatures_clone(orig: bigint): bigint {
39142 if(!isWasmInitialized) {
39143 throw new Error("initializeWasm() must be awaited first!");
39145 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone(orig);
39146 return nativeResponseValue;
39148 // uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
39150 export function ChannelTypeFeatures_clone_ptr(arg: bigint): bigint {
39151 if(!isWasmInitialized) {
39152 throw new Error("initializeWasm() must be awaited first!");
39154 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
39155 return nativeResponseValue;
39157 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
39159 export function ChannelTypeFeatures_clone(orig: bigint): bigint {
39160 if(!isWasmInitialized) {
39161 throw new Error("initializeWasm() must be awaited first!");
39163 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
39164 return nativeResponseValue;
39166 // void InitFeatures_free(struct LDKInitFeatures this_obj);
39168 export function InitFeatures_free(this_obj: bigint): void {
39169 if(!isWasmInitialized) {
39170 throw new Error("initializeWasm() must be awaited first!");
39172 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
39173 // debug statements here
39175 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
39177 export function NodeFeatures_free(this_obj: bigint): void {
39178 if(!isWasmInitialized) {
39179 throw new Error("initializeWasm() must be awaited first!");
39181 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
39182 // debug statements here
39184 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
39186 export function ChannelFeatures_free(this_obj: bigint): void {
39187 if(!isWasmInitialized) {
39188 throw new Error("initializeWasm() must be awaited first!");
39190 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
39191 // debug statements here
39193 // void Bolt11InvoiceFeatures_free(struct LDKBolt11InvoiceFeatures this_obj);
39195 export function Bolt11InvoiceFeatures_free(this_obj: bigint): void {
39196 if(!isWasmInitialized) {
39197 throw new Error("initializeWasm() must be awaited first!");
39199 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_free(this_obj);
39200 // debug statements here
39202 // void OfferFeatures_free(struct LDKOfferFeatures this_obj);
39204 export function OfferFeatures_free(this_obj: bigint): void {
39205 if(!isWasmInitialized) {
39206 throw new Error("initializeWasm() must be awaited first!");
39208 const nativeResponseValue = wasm.TS_OfferFeatures_free(this_obj);
39209 // debug statements here
39211 // void InvoiceRequestFeatures_free(struct LDKInvoiceRequestFeatures this_obj);
39213 export function InvoiceRequestFeatures_free(this_obj: bigint): void {
39214 if(!isWasmInitialized) {
39215 throw new Error("initializeWasm() must be awaited first!");
39217 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_free(this_obj);
39218 // debug statements here
39220 // void Bolt12InvoiceFeatures_free(struct LDKBolt12InvoiceFeatures this_obj);
39222 export function Bolt12InvoiceFeatures_free(this_obj: bigint): void {
39223 if(!isWasmInitialized) {
39224 throw new Error("initializeWasm() must be awaited first!");
39226 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_free(this_obj);
39227 // debug statements here
39229 // void BlindedHopFeatures_free(struct LDKBlindedHopFeatures this_obj);
39231 export function BlindedHopFeatures_free(this_obj: bigint): void {
39232 if(!isWasmInitialized) {
39233 throw new Error("initializeWasm() must be awaited first!");
39235 const nativeResponseValue = wasm.TS_BlindedHopFeatures_free(this_obj);
39236 // debug statements here
39238 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
39240 export function ChannelTypeFeatures_free(this_obj: bigint): void {
39241 if(!isWasmInitialized) {
39242 throw new Error("initializeWasm() must be awaited first!");
39244 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
39245 // debug statements here
39247 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
39249 export function InitFeatures_empty(): bigint {
39250 if(!isWasmInitialized) {
39251 throw new Error("initializeWasm() must be awaited first!");
39253 const nativeResponseValue = wasm.TS_InitFeatures_empty();
39254 return nativeResponseValue;
39256 // MUST_USE_RES bool InitFeatures_requires_unknown_bits_from(const struct LDKInitFeatures *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR other);
39258 export function InitFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39259 if(!isWasmInitialized) {
39260 throw new Error("initializeWasm() must be awaited first!");
39262 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits_from(this_arg, other);
39263 return nativeResponseValue;
39265 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39267 export function InitFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39268 if(!isWasmInitialized) {
39269 throw new Error("initializeWasm() must be awaited first!");
39271 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
39272 return nativeResponseValue;
39274 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_required_feature_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39276 export function InitFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39277 if(!isWasmInitialized) {
39278 throw new Error("initializeWasm() must be awaited first!");
39280 const nativeResponseValue = wasm.TS_InitFeatures_set_required_feature_bit(this_arg, bit);
39281 return nativeResponseValue;
39283 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_optional_feature_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39285 export function InitFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39286 if(!isWasmInitialized) {
39287 throw new Error("initializeWasm() must be awaited first!");
39289 const nativeResponseValue = wasm.TS_InitFeatures_set_optional_feature_bit(this_arg, bit);
39290 return nativeResponseValue;
39292 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_required_custom_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39294 export function InitFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39295 if(!isWasmInitialized) {
39296 throw new Error("initializeWasm() must be awaited first!");
39298 const nativeResponseValue = wasm.TS_InitFeatures_set_required_custom_bit(this_arg, bit);
39299 return nativeResponseValue;
39301 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_optional_custom_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39303 export function InitFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39304 if(!isWasmInitialized) {
39305 throw new Error("initializeWasm() must be awaited first!");
39307 const nativeResponseValue = wasm.TS_InitFeatures_set_optional_custom_bit(this_arg, bit);
39308 return nativeResponseValue;
39310 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
39312 export function NodeFeatures_empty(): bigint {
39313 if(!isWasmInitialized) {
39314 throw new Error("initializeWasm() must be awaited first!");
39316 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
39317 return nativeResponseValue;
39319 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits_from(const struct LDKNodeFeatures *NONNULL_PTR this_arg, const struct LDKNodeFeatures *NONNULL_PTR other);
39321 export function NodeFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39322 if(!isWasmInitialized) {
39323 throw new Error("initializeWasm() must be awaited first!");
39325 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits_from(this_arg, other);
39326 return nativeResponseValue;
39328 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39330 export function NodeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39331 if(!isWasmInitialized) {
39332 throw new Error("initializeWasm() must be awaited first!");
39334 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
39335 return nativeResponseValue;
39337 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_required_feature_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39339 export function NodeFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39340 if(!isWasmInitialized) {
39341 throw new Error("initializeWasm() must be awaited first!");
39343 const nativeResponseValue = wasm.TS_NodeFeatures_set_required_feature_bit(this_arg, bit);
39344 return nativeResponseValue;
39346 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_optional_feature_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39348 export function NodeFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39349 if(!isWasmInitialized) {
39350 throw new Error("initializeWasm() must be awaited first!");
39352 const nativeResponseValue = wasm.TS_NodeFeatures_set_optional_feature_bit(this_arg, bit);
39353 return nativeResponseValue;
39355 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_required_custom_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39357 export function NodeFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39358 if(!isWasmInitialized) {
39359 throw new Error("initializeWasm() must be awaited first!");
39361 const nativeResponseValue = wasm.TS_NodeFeatures_set_required_custom_bit(this_arg, bit);
39362 return nativeResponseValue;
39364 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_optional_custom_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39366 export function NodeFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39367 if(!isWasmInitialized) {
39368 throw new Error("initializeWasm() must be awaited first!");
39370 const nativeResponseValue = wasm.TS_NodeFeatures_set_optional_custom_bit(this_arg, bit);
39371 return nativeResponseValue;
39373 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
39375 export function ChannelFeatures_empty(): bigint {
39376 if(!isWasmInitialized) {
39377 throw new Error("initializeWasm() must be awaited first!");
39379 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
39380 return nativeResponseValue;
39382 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits_from(const struct LDKChannelFeatures *NONNULL_PTR this_arg, const struct LDKChannelFeatures *NONNULL_PTR other);
39384 export function ChannelFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39385 if(!isWasmInitialized) {
39386 throw new Error("initializeWasm() must be awaited first!");
39388 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits_from(this_arg, other);
39389 return nativeResponseValue;
39391 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
39393 export function ChannelFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39394 if(!isWasmInitialized) {
39395 throw new Error("initializeWasm() must be awaited first!");
39397 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
39398 return nativeResponseValue;
39400 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_required_feature_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39402 export function ChannelFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39403 if(!isWasmInitialized) {
39404 throw new Error("initializeWasm() must be awaited first!");
39406 const nativeResponseValue = wasm.TS_ChannelFeatures_set_required_feature_bit(this_arg, bit);
39407 return nativeResponseValue;
39409 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_optional_feature_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39411 export function ChannelFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39412 if(!isWasmInitialized) {
39413 throw new Error("initializeWasm() must be awaited first!");
39415 const nativeResponseValue = wasm.TS_ChannelFeatures_set_optional_feature_bit(this_arg, bit);
39416 return nativeResponseValue;
39418 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_required_custom_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39420 export function ChannelFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39421 if(!isWasmInitialized) {
39422 throw new Error("initializeWasm() must be awaited first!");
39424 const nativeResponseValue = wasm.TS_ChannelFeatures_set_required_custom_bit(this_arg, bit);
39425 return nativeResponseValue;
39427 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_optional_custom_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39429 export function ChannelFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39430 if(!isWasmInitialized) {
39431 throw new Error("initializeWasm() must be awaited first!");
39433 const nativeResponseValue = wasm.TS_ChannelFeatures_set_optional_custom_bit(this_arg, bit);
39434 return nativeResponseValue;
39436 // MUST_USE_RES struct LDKBolt11InvoiceFeatures Bolt11InvoiceFeatures_empty(void);
39438 export function Bolt11InvoiceFeatures_empty(): bigint {
39439 if(!isWasmInitialized) {
39440 throw new Error("initializeWasm() must be awaited first!");
39442 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_empty();
39443 return nativeResponseValue;
39445 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_unknown_bits_from(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, const struct LDKBolt11InvoiceFeatures *NONNULL_PTR other);
39447 export function Bolt11InvoiceFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39448 if(!isWasmInitialized) {
39449 throw new Error("initializeWasm() must be awaited first!");
39451 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_unknown_bits_from(this_arg, other);
39452 return nativeResponseValue;
39454 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_unknown_bits(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
39456 export function Bolt11InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39457 if(!isWasmInitialized) {
39458 throw new Error("initializeWasm() must be awaited first!");
39460 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_unknown_bits(this_arg);
39461 return nativeResponseValue;
39463 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_required_feature_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39465 export function Bolt11InvoiceFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39466 if(!isWasmInitialized) {
39467 throw new Error("initializeWasm() must be awaited first!");
39469 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_required_feature_bit(this_arg, bit);
39470 return nativeResponseValue;
39472 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_optional_feature_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39474 export function Bolt11InvoiceFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39475 if(!isWasmInitialized) {
39476 throw new Error("initializeWasm() must be awaited first!");
39478 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_optional_feature_bit(this_arg, bit);
39479 return nativeResponseValue;
39481 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_required_custom_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39483 export function Bolt11InvoiceFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39484 if(!isWasmInitialized) {
39485 throw new Error("initializeWasm() must be awaited first!");
39487 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_required_custom_bit(this_arg, bit);
39488 return nativeResponseValue;
39490 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_optional_custom_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39492 export function Bolt11InvoiceFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39493 if(!isWasmInitialized) {
39494 throw new Error("initializeWasm() must be awaited first!");
39496 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_optional_custom_bit(this_arg, bit);
39497 return nativeResponseValue;
39499 // MUST_USE_RES struct LDKOfferFeatures OfferFeatures_empty(void);
39501 export function OfferFeatures_empty(): bigint {
39502 if(!isWasmInitialized) {
39503 throw new Error("initializeWasm() must be awaited first!");
39505 const nativeResponseValue = wasm.TS_OfferFeatures_empty();
39506 return nativeResponseValue;
39508 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits_from(const struct LDKOfferFeatures *NONNULL_PTR this_arg, const struct LDKOfferFeatures *NONNULL_PTR other);
39510 export function OfferFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39511 if(!isWasmInitialized) {
39512 throw new Error("initializeWasm() must be awaited first!");
39514 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits_from(this_arg, other);
39515 return nativeResponseValue;
39517 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits(const struct LDKOfferFeatures *NONNULL_PTR this_arg);
39519 export function OfferFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39520 if(!isWasmInitialized) {
39521 throw new Error("initializeWasm() must be awaited first!");
39523 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits(this_arg);
39524 return nativeResponseValue;
39526 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_required_feature_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39528 export function OfferFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39529 if(!isWasmInitialized) {
39530 throw new Error("initializeWasm() must be awaited first!");
39532 const nativeResponseValue = wasm.TS_OfferFeatures_set_required_feature_bit(this_arg, bit);
39533 return nativeResponseValue;
39535 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_optional_feature_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39537 export function OfferFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39538 if(!isWasmInitialized) {
39539 throw new Error("initializeWasm() must be awaited first!");
39541 const nativeResponseValue = wasm.TS_OfferFeatures_set_optional_feature_bit(this_arg, bit);
39542 return nativeResponseValue;
39544 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_required_custom_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39546 export function OfferFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39547 if(!isWasmInitialized) {
39548 throw new Error("initializeWasm() must be awaited first!");
39550 const nativeResponseValue = wasm.TS_OfferFeatures_set_required_custom_bit(this_arg, bit);
39551 return nativeResponseValue;
39553 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_optional_custom_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39555 export function OfferFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39556 if(!isWasmInitialized) {
39557 throw new Error("initializeWasm() must be awaited first!");
39559 const nativeResponseValue = wasm.TS_OfferFeatures_set_optional_custom_bit(this_arg, bit);
39560 return nativeResponseValue;
39562 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_empty(void);
39564 export function InvoiceRequestFeatures_empty(): bigint {
39565 if(!isWasmInitialized) {
39566 throw new Error("initializeWasm() must be awaited first!");
39568 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_empty();
39569 return nativeResponseValue;
39571 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits_from(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, const struct LDKInvoiceRequestFeatures *NONNULL_PTR other);
39573 export function InvoiceRequestFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39574 if(!isWasmInitialized) {
39575 throw new Error("initializeWasm() must be awaited first!");
39577 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits_from(this_arg, other);
39578 return nativeResponseValue;
39580 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg);
39582 export function InvoiceRequestFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39583 if(!isWasmInitialized) {
39584 throw new Error("initializeWasm() must be awaited first!");
39586 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits(this_arg);
39587 return nativeResponseValue;
39589 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_required_feature_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39591 export function InvoiceRequestFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39592 if(!isWasmInitialized) {
39593 throw new Error("initializeWasm() must be awaited first!");
39595 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_required_feature_bit(this_arg, bit);
39596 return nativeResponseValue;
39598 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_optional_feature_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39600 export function InvoiceRequestFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39601 if(!isWasmInitialized) {
39602 throw new Error("initializeWasm() must be awaited first!");
39604 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_optional_feature_bit(this_arg, bit);
39605 return nativeResponseValue;
39607 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_required_custom_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39609 export function InvoiceRequestFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39610 if(!isWasmInitialized) {
39611 throw new Error("initializeWasm() must be awaited first!");
39613 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_required_custom_bit(this_arg, bit);
39614 return nativeResponseValue;
39616 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_optional_custom_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39618 export function InvoiceRequestFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39619 if(!isWasmInitialized) {
39620 throw new Error("initializeWasm() must be awaited first!");
39622 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_optional_custom_bit(this_arg, bit);
39623 return nativeResponseValue;
39625 // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_empty(void);
39627 export function Bolt12InvoiceFeatures_empty(): bigint {
39628 if(!isWasmInitialized) {
39629 throw new Error("initializeWasm() must be awaited first!");
39631 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_empty();
39632 return nativeResponseValue;
39634 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_unknown_bits_from(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, const struct LDKBolt12InvoiceFeatures *NONNULL_PTR other);
39636 export function Bolt12InvoiceFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39637 if(!isWasmInitialized) {
39638 throw new Error("initializeWasm() must be awaited first!");
39640 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_unknown_bits_from(this_arg, other);
39641 return nativeResponseValue;
39643 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_unknown_bits(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
39645 export function Bolt12InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39646 if(!isWasmInitialized) {
39647 throw new Error("initializeWasm() must be awaited first!");
39649 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_unknown_bits(this_arg);
39650 return nativeResponseValue;
39652 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_required_feature_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39654 export function Bolt12InvoiceFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39655 if(!isWasmInitialized) {
39656 throw new Error("initializeWasm() must be awaited first!");
39658 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_required_feature_bit(this_arg, bit);
39659 return nativeResponseValue;
39661 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_optional_feature_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39663 export function Bolt12InvoiceFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39664 if(!isWasmInitialized) {
39665 throw new Error("initializeWasm() must be awaited first!");
39667 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_optional_feature_bit(this_arg, bit);
39668 return nativeResponseValue;
39670 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_required_custom_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39672 export function Bolt12InvoiceFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39673 if(!isWasmInitialized) {
39674 throw new Error("initializeWasm() must be awaited first!");
39676 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_required_custom_bit(this_arg, bit);
39677 return nativeResponseValue;
39679 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_optional_custom_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39681 export function Bolt12InvoiceFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39682 if(!isWasmInitialized) {
39683 throw new Error("initializeWasm() must be awaited first!");
39685 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_optional_custom_bit(this_arg, bit);
39686 return nativeResponseValue;
39688 // MUST_USE_RES struct LDKBlindedHopFeatures BlindedHopFeatures_empty(void);
39690 export function BlindedHopFeatures_empty(): bigint {
39691 if(!isWasmInitialized) {
39692 throw new Error("initializeWasm() must be awaited first!");
39694 const nativeResponseValue = wasm.TS_BlindedHopFeatures_empty();
39695 return nativeResponseValue;
39697 // MUST_USE_RES bool BlindedHopFeatures_requires_unknown_bits_from(const struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, const struct LDKBlindedHopFeatures *NONNULL_PTR other);
39699 export function BlindedHopFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39700 if(!isWasmInitialized) {
39701 throw new Error("initializeWasm() must be awaited first!");
39703 const nativeResponseValue = wasm.TS_BlindedHopFeatures_requires_unknown_bits_from(this_arg, other);
39704 return nativeResponseValue;
39706 // MUST_USE_RES bool BlindedHopFeatures_requires_unknown_bits(const struct LDKBlindedHopFeatures *NONNULL_PTR this_arg);
39708 export function BlindedHopFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39709 if(!isWasmInitialized) {
39710 throw new Error("initializeWasm() must be awaited first!");
39712 const nativeResponseValue = wasm.TS_BlindedHopFeatures_requires_unknown_bits(this_arg);
39713 return nativeResponseValue;
39715 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_required_feature_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39717 export function BlindedHopFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39718 if(!isWasmInitialized) {
39719 throw new Error("initializeWasm() must be awaited first!");
39721 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_required_feature_bit(this_arg, bit);
39722 return nativeResponseValue;
39724 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_optional_feature_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39726 export function BlindedHopFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39727 if(!isWasmInitialized) {
39728 throw new Error("initializeWasm() must be awaited first!");
39730 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_optional_feature_bit(this_arg, bit);
39731 return nativeResponseValue;
39733 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_required_custom_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39735 export function BlindedHopFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39736 if(!isWasmInitialized) {
39737 throw new Error("initializeWasm() must be awaited first!");
39739 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_required_custom_bit(this_arg, bit);
39740 return nativeResponseValue;
39742 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_optional_custom_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39744 export function BlindedHopFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39745 if(!isWasmInitialized) {
39746 throw new Error("initializeWasm() must be awaited first!");
39748 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_optional_custom_bit(this_arg, bit);
39749 return nativeResponseValue;
39751 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
39753 export function ChannelTypeFeatures_empty(): bigint {
39754 if(!isWasmInitialized) {
39755 throw new Error("initializeWasm() must be awaited first!");
39757 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
39758 return nativeResponseValue;
39760 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits_from(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, const struct LDKChannelTypeFeatures *NONNULL_PTR other);
39762 export function ChannelTypeFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
39763 if(!isWasmInitialized) {
39764 throw new Error("initializeWasm() must be awaited first!");
39766 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits_from(this_arg, other);
39767 return nativeResponseValue;
39769 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
39771 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
39772 if(!isWasmInitialized) {
39773 throw new Error("initializeWasm() must be awaited first!");
39775 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
39776 return nativeResponseValue;
39778 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_required_feature_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39780 export function ChannelTypeFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
39781 if(!isWasmInitialized) {
39782 throw new Error("initializeWasm() must be awaited first!");
39784 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_required_feature_bit(this_arg, bit);
39785 return nativeResponseValue;
39787 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_optional_feature_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39789 export function ChannelTypeFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
39790 if(!isWasmInitialized) {
39791 throw new Error("initializeWasm() must be awaited first!");
39793 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_optional_feature_bit(this_arg, bit);
39794 return nativeResponseValue;
39796 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_required_custom_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39798 export function ChannelTypeFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
39799 if(!isWasmInitialized) {
39800 throw new Error("initializeWasm() must be awaited first!");
39802 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_required_custom_bit(this_arg, bit);
39803 return nativeResponseValue;
39805 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_optional_custom_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
39807 export function ChannelTypeFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
39808 if(!isWasmInitialized) {
39809 throw new Error("initializeWasm() must be awaited first!");
39811 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_optional_custom_bit(this_arg, bit);
39812 return nativeResponseValue;
39814 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
39816 export function InitFeatures_write(obj: bigint): number {
39817 if(!isWasmInitialized) {
39818 throw new Error("initializeWasm() must be awaited first!");
39820 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
39821 return nativeResponseValue;
39823 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
39825 export function InitFeatures_read(ser: number): bigint {
39826 if(!isWasmInitialized) {
39827 throw new Error("initializeWasm() must be awaited first!");
39829 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
39830 return nativeResponseValue;
39832 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
39834 export function ChannelFeatures_write(obj: bigint): number {
39835 if(!isWasmInitialized) {
39836 throw new Error("initializeWasm() must be awaited first!");
39838 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
39839 return nativeResponseValue;
39841 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
39843 export function ChannelFeatures_read(ser: number): bigint {
39844 if(!isWasmInitialized) {
39845 throw new Error("initializeWasm() must be awaited first!");
39847 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
39848 return nativeResponseValue;
39850 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
39852 export function NodeFeatures_write(obj: bigint): number {
39853 if(!isWasmInitialized) {
39854 throw new Error("initializeWasm() must be awaited first!");
39856 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
39857 return nativeResponseValue;
39859 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
39861 export function NodeFeatures_read(ser: number): bigint {
39862 if(!isWasmInitialized) {
39863 throw new Error("initializeWasm() must be awaited first!");
39865 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
39866 return nativeResponseValue;
39868 // struct LDKCVec_u8Z Bolt11InvoiceFeatures_write(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR obj);
39870 export function Bolt11InvoiceFeatures_write(obj: bigint): number {
39871 if(!isWasmInitialized) {
39872 throw new Error("initializeWasm() must be awaited first!");
39874 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_write(obj);
39875 return nativeResponseValue;
39877 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ Bolt11InvoiceFeatures_read(struct LDKu8slice ser);
39879 export function Bolt11InvoiceFeatures_read(ser: number): bigint {
39880 if(!isWasmInitialized) {
39881 throw new Error("initializeWasm() must be awaited first!");
39883 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_read(ser);
39884 return nativeResponseValue;
39886 // struct LDKCVec_u8Z Bolt12InvoiceFeatures_write(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR obj);
39888 export function Bolt12InvoiceFeatures_write(obj: bigint): number {
39889 if(!isWasmInitialized) {
39890 throw new Error("initializeWasm() must be awaited first!");
39892 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_write(obj);
39893 return nativeResponseValue;
39895 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ Bolt12InvoiceFeatures_read(struct LDKu8slice ser);
39897 export function Bolt12InvoiceFeatures_read(ser: number): bigint {
39898 if(!isWasmInitialized) {
39899 throw new Error("initializeWasm() must be awaited first!");
39901 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_read(ser);
39902 return nativeResponseValue;
39904 // struct LDKCVec_u8Z BlindedHopFeatures_write(const struct LDKBlindedHopFeatures *NONNULL_PTR obj);
39906 export function BlindedHopFeatures_write(obj: bigint): number {
39907 if(!isWasmInitialized) {
39908 throw new Error("initializeWasm() must be awaited first!");
39910 const nativeResponseValue = wasm.TS_BlindedHopFeatures_write(obj);
39911 return nativeResponseValue;
39913 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ BlindedHopFeatures_read(struct LDKu8slice ser);
39915 export function BlindedHopFeatures_read(ser: number): bigint {
39916 if(!isWasmInitialized) {
39917 throw new Error("initializeWasm() must be awaited first!");
39919 const nativeResponseValue = wasm.TS_BlindedHopFeatures_read(ser);
39920 return nativeResponseValue;
39922 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
39924 export function ChannelTypeFeatures_write(obj: bigint): number {
39925 if(!isWasmInitialized) {
39926 throw new Error("initializeWasm() must be awaited first!");
39928 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
39929 return nativeResponseValue;
39931 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
39933 export function ChannelTypeFeatures_read(ser: number): bigint {
39934 if(!isWasmInitialized) {
39935 throw new Error("initializeWasm() must be awaited first!");
39937 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
39938 return nativeResponseValue;
39940 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
39942 export function InitFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
39943 if(!isWasmInitialized) {
39944 throw new Error("initializeWasm() must be awaited first!");
39946 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
39947 // debug statements here
39949 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
39951 export function InitFeatures_set_data_loss_protect_required(this_arg: bigint): void {
39952 if(!isWasmInitialized) {
39953 throw new Error("initializeWasm() must be awaited first!");
39955 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
39956 // debug statements here
39958 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39960 export function InitFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
39961 if(!isWasmInitialized) {
39962 throw new Error("initializeWasm() must be awaited first!");
39964 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
39965 return nativeResponseValue;
39967 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39969 export function NodeFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
39970 if(!isWasmInitialized) {
39971 throw new Error("initializeWasm() must be awaited first!");
39973 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
39974 // debug statements here
39976 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
39978 export function NodeFeatures_set_data_loss_protect_required(this_arg: bigint): void {
39979 if(!isWasmInitialized) {
39980 throw new Error("initializeWasm() must be awaited first!");
39982 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
39983 // debug statements here
39985 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
39987 export function NodeFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
39988 if(!isWasmInitialized) {
39989 throw new Error("initializeWasm() must be awaited first!");
39991 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
39992 return nativeResponseValue;
39994 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
39996 export function InitFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
39997 if(!isWasmInitialized) {
39998 throw new Error("initializeWasm() must be awaited first!");
40000 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
40001 return nativeResponseValue;
40003 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40005 export function NodeFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
40006 if(!isWasmInitialized) {
40007 throw new Error("initializeWasm() must be awaited first!");
40009 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
40010 return nativeResponseValue;
40012 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40014 export function InitFeatures_set_initial_routing_sync_optional(this_arg: bigint): void {
40015 if(!isWasmInitialized) {
40016 throw new Error("initializeWasm() must be awaited first!");
40018 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
40019 // debug statements here
40021 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40023 export function InitFeatures_set_initial_routing_sync_required(this_arg: bigint): void {
40024 if(!isWasmInitialized) {
40025 throw new Error("initializeWasm() must be awaited first!");
40027 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
40028 // debug statements here
40030 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40032 export function InitFeatures_initial_routing_sync(this_arg: bigint): boolean {
40033 if(!isWasmInitialized) {
40034 throw new Error("initializeWasm() must be awaited first!");
40036 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
40037 return nativeResponseValue;
40039 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40041 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
40042 if(!isWasmInitialized) {
40043 throw new Error("initializeWasm() must be awaited first!");
40045 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
40046 // debug statements here
40048 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40050 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
40051 if(!isWasmInitialized) {
40052 throw new Error("initializeWasm() must be awaited first!");
40054 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
40055 // debug statements here
40057 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40059 export function InitFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
40060 if(!isWasmInitialized) {
40061 throw new Error("initializeWasm() must be awaited first!");
40063 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
40064 return nativeResponseValue;
40066 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40068 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
40069 if(!isWasmInitialized) {
40070 throw new Error("initializeWasm() must be awaited first!");
40072 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
40073 // debug statements here
40075 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40077 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
40078 if(!isWasmInitialized) {
40079 throw new Error("initializeWasm() must be awaited first!");
40081 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
40082 // debug statements here
40084 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40086 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
40087 if(!isWasmInitialized) {
40088 throw new Error("initializeWasm() must be awaited first!");
40090 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
40091 return nativeResponseValue;
40093 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40095 export function InitFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
40096 if(!isWasmInitialized) {
40097 throw new Error("initializeWasm() must be awaited first!");
40099 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
40100 return nativeResponseValue;
40102 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40104 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
40105 if(!isWasmInitialized) {
40106 throw new Error("initializeWasm() must be awaited first!");
40108 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
40109 return nativeResponseValue;
40111 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40113 export function InitFeatures_set_gossip_queries_optional(this_arg: bigint): void {
40114 if(!isWasmInitialized) {
40115 throw new Error("initializeWasm() must be awaited first!");
40117 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
40118 // debug statements here
40120 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40122 export function InitFeatures_set_gossip_queries_required(this_arg: bigint): void {
40123 if(!isWasmInitialized) {
40124 throw new Error("initializeWasm() must be awaited first!");
40126 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
40127 // debug statements here
40129 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40131 export function InitFeatures_supports_gossip_queries(this_arg: bigint): boolean {
40132 if(!isWasmInitialized) {
40133 throw new Error("initializeWasm() must be awaited first!");
40135 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
40136 return nativeResponseValue;
40138 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40140 export function NodeFeatures_set_gossip_queries_optional(this_arg: bigint): void {
40141 if(!isWasmInitialized) {
40142 throw new Error("initializeWasm() must be awaited first!");
40144 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
40145 // debug statements here
40147 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40149 export function NodeFeatures_set_gossip_queries_required(this_arg: bigint): void {
40150 if(!isWasmInitialized) {
40151 throw new Error("initializeWasm() must be awaited first!");
40153 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
40154 // debug statements here
40156 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40158 export function NodeFeatures_supports_gossip_queries(this_arg: bigint): boolean {
40159 if(!isWasmInitialized) {
40160 throw new Error("initializeWasm() must be awaited first!");
40162 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
40163 return nativeResponseValue;
40165 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40167 export function InitFeatures_requires_gossip_queries(this_arg: bigint): boolean {
40168 if(!isWasmInitialized) {
40169 throw new Error("initializeWasm() must be awaited first!");
40171 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
40172 return nativeResponseValue;
40174 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40176 export function NodeFeatures_requires_gossip_queries(this_arg: bigint): boolean {
40177 if(!isWasmInitialized) {
40178 throw new Error("initializeWasm() must be awaited first!");
40180 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
40181 return nativeResponseValue;
40183 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40185 export function InitFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
40186 if(!isWasmInitialized) {
40187 throw new Error("initializeWasm() must be awaited first!");
40189 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
40190 // debug statements here
40192 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40194 export function InitFeatures_set_variable_length_onion_required(this_arg: bigint): void {
40195 if(!isWasmInitialized) {
40196 throw new Error("initializeWasm() must be awaited first!");
40198 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
40199 // debug statements here
40201 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40203 export function InitFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
40204 if(!isWasmInitialized) {
40205 throw new Error("initializeWasm() must be awaited first!");
40207 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
40208 return nativeResponseValue;
40210 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40212 export function NodeFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
40213 if(!isWasmInitialized) {
40214 throw new Error("initializeWasm() must be awaited first!");
40216 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
40217 // debug statements here
40219 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40221 export function NodeFeatures_set_variable_length_onion_required(this_arg: bigint): void {
40222 if(!isWasmInitialized) {
40223 throw new Error("initializeWasm() must be awaited first!");
40225 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
40226 // debug statements here
40228 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40230 export function NodeFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
40231 if(!isWasmInitialized) {
40232 throw new Error("initializeWasm() must be awaited first!");
40234 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
40235 return nativeResponseValue;
40237 // void Bolt11InvoiceFeatures_set_variable_length_onion_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40239 export function Bolt11InvoiceFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
40240 if(!isWasmInitialized) {
40241 throw new Error("initializeWasm() must be awaited first!");
40243 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_variable_length_onion_optional(this_arg);
40244 // debug statements here
40246 // void Bolt11InvoiceFeatures_set_variable_length_onion_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40248 export function Bolt11InvoiceFeatures_set_variable_length_onion_required(this_arg: bigint): void {
40249 if(!isWasmInitialized) {
40250 throw new Error("initializeWasm() must be awaited first!");
40252 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_variable_length_onion_required(this_arg);
40253 // debug statements here
40255 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_variable_length_onion(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40257 export function Bolt11InvoiceFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
40258 if(!isWasmInitialized) {
40259 throw new Error("initializeWasm() must be awaited first!");
40261 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_variable_length_onion(this_arg);
40262 return nativeResponseValue;
40264 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40266 export function InitFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
40267 if(!isWasmInitialized) {
40268 throw new Error("initializeWasm() must be awaited first!");
40270 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
40271 return nativeResponseValue;
40273 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40275 export function NodeFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
40276 if(!isWasmInitialized) {
40277 throw new Error("initializeWasm() must be awaited first!");
40279 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
40280 return nativeResponseValue;
40282 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_variable_length_onion(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40284 export function Bolt11InvoiceFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
40285 if(!isWasmInitialized) {
40286 throw new Error("initializeWasm() must be awaited first!");
40288 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_variable_length_onion(this_arg);
40289 return nativeResponseValue;
40291 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40293 export function InitFeatures_set_static_remote_key_optional(this_arg: bigint): void {
40294 if(!isWasmInitialized) {
40295 throw new Error("initializeWasm() must be awaited first!");
40297 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
40298 // debug statements here
40300 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40302 export function InitFeatures_set_static_remote_key_required(this_arg: bigint): void {
40303 if(!isWasmInitialized) {
40304 throw new Error("initializeWasm() must be awaited first!");
40306 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
40307 // debug statements here
40309 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40311 export function InitFeatures_supports_static_remote_key(this_arg: bigint): boolean {
40312 if(!isWasmInitialized) {
40313 throw new Error("initializeWasm() must be awaited first!");
40315 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
40316 return nativeResponseValue;
40318 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40320 export function NodeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
40321 if(!isWasmInitialized) {
40322 throw new Error("initializeWasm() must be awaited first!");
40324 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
40325 // debug statements here
40327 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40329 export function NodeFeatures_set_static_remote_key_required(this_arg: bigint): void {
40330 if(!isWasmInitialized) {
40331 throw new Error("initializeWasm() must be awaited first!");
40333 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
40334 // debug statements here
40336 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40338 export function NodeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
40339 if(!isWasmInitialized) {
40340 throw new Error("initializeWasm() must be awaited first!");
40342 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
40343 return nativeResponseValue;
40345 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40347 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
40348 if(!isWasmInitialized) {
40349 throw new Error("initializeWasm() must be awaited first!");
40351 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
40352 // debug statements here
40354 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40356 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: bigint): void {
40357 if(!isWasmInitialized) {
40358 throw new Error("initializeWasm() must be awaited first!");
40360 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
40361 // debug statements here
40363 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40365 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
40366 if(!isWasmInitialized) {
40367 throw new Error("initializeWasm() must be awaited first!");
40369 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
40370 return nativeResponseValue;
40372 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40374 export function InitFeatures_requires_static_remote_key(this_arg: bigint): boolean {
40375 if(!isWasmInitialized) {
40376 throw new Error("initializeWasm() must be awaited first!");
40378 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
40379 return nativeResponseValue;
40381 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40383 export function NodeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
40384 if(!isWasmInitialized) {
40385 throw new Error("initializeWasm() must be awaited first!");
40387 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
40388 return nativeResponseValue;
40390 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40392 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
40393 if(!isWasmInitialized) {
40394 throw new Error("initializeWasm() must be awaited first!");
40396 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
40397 return nativeResponseValue;
40399 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40401 export function InitFeatures_set_payment_secret_optional(this_arg: bigint): void {
40402 if(!isWasmInitialized) {
40403 throw new Error("initializeWasm() must be awaited first!");
40405 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
40406 // debug statements here
40408 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40410 export function InitFeatures_set_payment_secret_required(this_arg: bigint): void {
40411 if(!isWasmInitialized) {
40412 throw new Error("initializeWasm() must be awaited first!");
40414 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
40415 // debug statements here
40417 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40419 export function InitFeatures_supports_payment_secret(this_arg: bigint): boolean {
40420 if(!isWasmInitialized) {
40421 throw new Error("initializeWasm() must be awaited first!");
40423 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
40424 return nativeResponseValue;
40426 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40428 export function NodeFeatures_set_payment_secret_optional(this_arg: bigint): void {
40429 if(!isWasmInitialized) {
40430 throw new Error("initializeWasm() must be awaited first!");
40432 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
40433 // debug statements here
40435 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40437 export function NodeFeatures_set_payment_secret_required(this_arg: bigint): void {
40438 if(!isWasmInitialized) {
40439 throw new Error("initializeWasm() must be awaited first!");
40441 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
40442 // debug statements here
40444 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40446 export function NodeFeatures_supports_payment_secret(this_arg: bigint): boolean {
40447 if(!isWasmInitialized) {
40448 throw new Error("initializeWasm() must be awaited first!");
40450 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
40451 return nativeResponseValue;
40453 // void Bolt11InvoiceFeatures_set_payment_secret_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40455 export function Bolt11InvoiceFeatures_set_payment_secret_optional(this_arg: bigint): void {
40456 if(!isWasmInitialized) {
40457 throw new Error("initializeWasm() must be awaited first!");
40459 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_secret_optional(this_arg);
40460 // debug statements here
40462 // void Bolt11InvoiceFeatures_set_payment_secret_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40464 export function Bolt11InvoiceFeatures_set_payment_secret_required(this_arg: bigint): void {
40465 if(!isWasmInitialized) {
40466 throw new Error("initializeWasm() must be awaited first!");
40468 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_secret_required(this_arg);
40469 // debug statements here
40471 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_payment_secret(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40473 export function Bolt11InvoiceFeatures_supports_payment_secret(this_arg: bigint): boolean {
40474 if(!isWasmInitialized) {
40475 throw new Error("initializeWasm() must be awaited first!");
40477 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_payment_secret(this_arg);
40478 return nativeResponseValue;
40480 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40482 export function InitFeatures_requires_payment_secret(this_arg: bigint): boolean {
40483 if(!isWasmInitialized) {
40484 throw new Error("initializeWasm() must be awaited first!");
40486 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
40487 return nativeResponseValue;
40489 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40491 export function NodeFeatures_requires_payment_secret(this_arg: bigint): boolean {
40492 if(!isWasmInitialized) {
40493 throw new Error("initializeWasm() must be awaited first!");
40495 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
40496 return nativeResponseValue;
40498 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_payment_secret(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40500 export function Bolt11InvoiceFeatures_requires_payment_secret(this_arg: bigint): boolean {
40501 if(!isWasmInitialized) {
40502 throw new Error("initializeWasm() must be awaited first!");
40504 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_payment_secret(this_arg);
40505 return nativeResponseValue;
40507 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40509 export function InitFeatures_set_basic_mpp_optional(this_arg: bigint): void {
40510 if(!isWasmInitialized) {
40511 throw new Error("initializeWasm() must be awaited first!");
40513 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
40514 // debug statements here
40516 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40518 export function InitFeatures_set_basic_mpp_required(this_arg: bigint): void {
40519 if(!isWasmInitialized) {
40520 throw new Error("initializeWasm() must be awaited first!");
40522 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
40523 // debug statements here
40525 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40527 export function InitFeatures_supports_basic_mpp(this_arg: bigint): boolean {
40528 if(!isWasmInitialized) {
40529 throw new Error("initializeWasm() must be awaited first!");
40531 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
40532 return nativeResponseValue;
40534 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40536 export function NodeFeatures_set_basic_mpp_optional(this_arg: bigint): void {
40537 if(!isWasmInitialized) {
40538 throw new Error("initializeWasm() must be awaited first!");
40540 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
40541 // debug statements here
40543 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40545 export function NodeFeatures_set_basic_mpp_required(this_arg: bigint): void {
40546 if(!isWasmInitialized) {
40547 throw new Error("initializeWasm() must be awaited first!");
40549 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
40550 // debug statements here
40552 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40554 export function NodeFeatures_supports_basic_mpp(this_arg: bigint): boolean {
40555 if(!isWasmInitialized) {
40556 throw new Error("initializeWasm() must be awaited first!");
40558 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
40559 return nativeResponseValue;
40561 // void Bolt11InvoiceFeatures_set_basic_mpp_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40563 export function Bolt11InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
40564 if(!isWasmInitialized) {
40565 throw new Error("initializeWasm() must be awaited first!");
40567 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_basic_mpp_optional(this_arg);
40568 // debug statements here
40570 // void Bolt11InvoiceFeatures_set_basic_mpp_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40572 export function Bolt11InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
40573 if(!isWasmInitialized) {
40574 throw new Error("initializeWasm() must be awaited first!");
40576 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_basic_mpp_required(this_arg);
40577 // debug statements here
40579 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_basic_mpp(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40581 export function Bolt11InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
40582 if(!isWasmInitialized) {
40583 throw new Error("initializeWasm() must be awaited first!");
40585 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_basic_mpp(this_arg);
40586 return nativeResponseValue;
40588 // void Bolt12InvoiceFeatures_set_basic_mpp_optional(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
40590 export function Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
40591 if(!isWasmInitialized) {
40592 throw new Error("initializeWasm() must be awaited first!");
40594 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg);
40595 // debug statements here
40597 // void Bolt12InvoiceFeatures_set_basic_mpp_required(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
40599 export function Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
40600 if(!isWasmInitialized) {
40601 throw new Error("initializeWasm() must be awaited first!");
40603 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg);
40604 // debug statements here
40606 // MUST_USE_RES bool Bolt12InvoiceFeatures_supports_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
40608 export function Bolt12InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
40609 if(!isWasmInitialized) {
40610 throw new Error("initializeWasm() must be awaited first!");
40612 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_supports_basic_mpp(this_arg);
40613 return nativeResponseValue;
40615 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40617 export function InitFeatures_requires_basic_mpp(this_arg: bigint): boolean {
40618 if(!isWasmInitialized) {
40619 throw new Error("initializeWasm() must be awaited first!");
40621 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
40622 return nativeResponseValue;
40624 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40626 export function NodeFeatures_requires_basic_mpp(this_arg: bigint): boolean {
40627 if(!isWasmInitialized) {
40628 throw new Error("initializeWasm() must be awaited first!");
40630 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
40631 return nativeResponseValue;
40633 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_basic_mpp(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
40635 export function Bolt11InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
40636 if(!isWasmInitialized) {
40637 throw new Error("initializeWasm() must be awaited first!");
40639 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_basic_mpp(this_arg);
40640 return nativeResponseValue;
40642 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
40644 export function Bolt12InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
40645 if(!isWasmInitialized) {
40646 throw new Error("initializeWasm() must be awaited first!");
40648 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_basic_mpp(this_arg);
40649 return nativeResponseValue;
40651 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40653 export function InitFeatures_set_wumbo_optional(this_arg: bigint): void {
40654 if(!isWasmInitialized) {
40655 throw new Error("initializeWasm() must be awaited first!");
40657 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
40658 // debug statements here
40660 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40662 export function InitFeatures_set_wumbo_required(this_arg: bigint): void {
40663 if(!isWasmInitialized) {
40664 throw new Error("initializeWasm() must be awaited first!");
40666 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
40667 // debug statements here
40669 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40671 export function InitFeatures_supports_wumbo(this_arg: bigint): boolean {
40672 if(!isWasmInitialized) {
40673 throw new Error("initializeWasm() must be awaited first!");
40675 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
40676 return nativeResponseValue;
40678 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40680 export function NodeFeatures_set_wumbo_optional(this_arg: bigint): void {
40681 if(!isWasmInitialized) {
40682 throw new Error("initializeWasm() must be awaited first!");
40684 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
40685 // debug statements here
40687 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40689 export function NodeFeatures_set_wumbo_required(this_arg: bigint): void {
40690 if(!isWasmInitialized) {
40691 throw new Error("initializeWasm() must be awaited first!");
40693 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
40694 // debug statements here
40696 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40698 export function NodeFeatures_supports_wumbo(this_arg: bigint): boolean {
40699 if(!isWasmInitialized) {
40700 throw new Error("initializeWasm() must be awaited first!");
40702 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
40703 return nativeResponseValue;
40705 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40707 export function InitFeatures_requires_wumbo(this_arg: bigint): boolean {
40708 if(!isWasmInitialized) {
40709 throw new Error("initializeWasm() must be awaited first!");
40711 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
40712 return nativeResponseValue;
40714 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40716 export function NodeFeatures_requires_wumbo(this_arg: bigint): boolean {
40717 if(!isWasmInitialized) {
40718 throw new Error("initializeWasm() must be awaited first!");
40720 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
40721 return nativeResponseValue;
40723 // void InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40725 export function InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
40726 if(!isWasmInitialized) {
40727 throw new Error("initializeWasm() must be awaited first!");
40729 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
40730 // debug statements here
40732 // void InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40734 export function InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
40735 if(!isWasmInitialized) {
40736 throw new Error("initializeWasm() must be awaited first!");
40738 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
40739 // debug statements here
40741 // MUST_USE_RES bool InitFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40743 export function InitFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40744 if(!isWasmInitialized) {
40745 throw new Error("initializeWasm() must be awaited first!");
40747 const nativeResponseValue = wasm.TS_InitFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
40748 return nativeResponseValue;
40750 // void NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40752 export function NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
40753 if(!isWasmInitialized) {
40754 throw new Error("initializeWasm() must be awaited first!");
40756 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
40757 // debug statements here
40759 // void NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40761 export function NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
40762 if(!isWasmInitialized) {
40763 throw new Error("initializeWasm() must be awaited first!");
40765 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
40766 // debug statements here
40768 // MUST_USE_RES bool NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40770 export function NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40771 if(!isWasmInitialized) {
40772 throw new Error("initializeWasm() must be awaited first!");
40774 const nativeResponseValue = wasm.TS_NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
40775 return nativeResponseValue;
40777 // void ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40779 export function ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
40780 if(!isWasmInitialized) {
40781 throw new Error("initializeWasm() must be awaited first!");
40783 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
40784 // debug statements here
40786 // void ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40788 export function ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
40789 if(!isWasmInitialized) {
40790 throw new Error("initializeWasm() must be awaited first!");
40792 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
40793 // debug statements here
40795 // MUST_USE_RES bool ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40797 export function ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40798 if(!isWasmInitialized) {
40799 throw new Error("initializeWasm() must be awaited first!");
40801 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
40802 return nativeResponseValue;
40804 // MUST_USE_RES bool InitFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40806 export function InitFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40807 if(!isWasmInitialized) {
40808 throw new Error("initializeWasm() must be awaited first!");
40810 const nativeResponseValue = wasm.TS_InitFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
40811 return nativeResponseValue;
40813 // MUST_USE_RES bool NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40815 export function NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40816 if(!isWasmInitialized) {
40817 throw new Error("initializeWasm() must be awaited first!");
40819 const nativeResponseValue = wasm.TS_NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
40820 return nativeResponseValue;
40822 // MUST_USE_RES bool ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40824 export function ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
40825 if(!isWasmInitialized) {
40826 throw new Error("initializeWasm() must be awaited first!");
40828 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
40829 return nativeResponseValue;
40831 // void InitFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40833 export function InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
40834 if(!isWasmInitialized) {
40835 throw new Error("initializeWasm() must be awaited first!");
40837 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
40838 // debug statements here
40840 // void InitFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40842 export function InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
40843 if(!isWasmInitialized) {
40844 throw new Error("initializeWasm() must be awaited first!");
40846 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
40847 // debug statements here
40849 // MUST_USE_RES bool InitFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40851 export function InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40852 if(!isWasmInitialized) {
40853 throw new Error("initializeWasm() must be awaited first!");
40855 const nativeResponseValue = wasm.TS_InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
40856 return nativeResponseValue;
40858 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40860 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
40861 if(!isWasmInitialized) {
40862 throw new Error("initializeWasm() must be awaited first!");
40864 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
40865 // debug statements here
40867 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40869 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
40870 if(!isWasmInitialized) {
40871 throw new Error("initializeWasm() must be awaited first!");
40873 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
40874 // debug statements here
40876 // MUST_USE_RES bool NodeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40878 export function NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40879 if(!isWasmInitialized) {
40880 throw new Error("initializeWasm() must be awaited first!");
40882 const nativeResponseValue = wasm.TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
40883 return nativeResponseValue;
40885 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40887 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
40888 if(!isWasmInitialized) {
40889 throw new Error("initializeWasm() must be awaited first!");
40891 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
40892 // debug statements here
40894 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40896 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
40897 if(!isWasmInitialized) {
40898 throw new Error("initializeWasm() must be awaited first!");
40900 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
40901 // debug statements here
40903 // MUST_USE_RES bool ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40905 export function ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40906 if(!isWasmInitialized) {
40907 throw new Error("initializeWasm() must be awaited first!");
40909 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
40910 return nativeResponseValue;
40912 // MUST_USE_RES bool InitFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40914 export function InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40915 if(!isWasmInitialized) {
40916 throw new Error("initializeWasm() must be awaited first!");
40918 const nativeResponseValue = wasm.TS_InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
40919 return nativeResponseValue;
40921 // MUST_USE_RES bool NodeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40923 export function NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40924 if(!isWasmInitialized) {
40925 throw new Error("initializeWasm() must be awaited first!");
40927 const nativeResponseValue = wasm.TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
40928 return nativeResponseValue;
40930 // MUST_USE_RES bool ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
40932 export function ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
40933 if(!isWasmInitialized) {
40934 throw new Error("initializeWasm() must be awaited first!");
40936 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
40937 return nativeResponseValue;
40939 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
40941 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
40942 if(!isWasmInitialized) {
40943 throw new Error("initializeWasm() must be awaited first!");
40945 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
40946 // debug statements here
40948 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
40950 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
40951 if(!isWasmInitialized) {
40952 throw new Error("initializeWasm() must be awaited first!");
40954 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
40955 // debug statements here
40957 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40959 export function InitFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
40960 if(!isWasmInitialized) {
40961 throw new Error("initializeWasm() must be awaited first!");
40963 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
40964 return nativeResponseValue;
40966 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40968 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
40969 if(!isWasmInitialized) {
40970 throw new Error("initializeWasm() must be awaited first!");
40972 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
40973 // debug statements here
40975 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
40977 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
40978 if(!isWasmInitialized) {
40979 throw new Error("initializeWasm() must be awaited first!");
40981 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
40982 // debug statements here
40984 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
40986 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
40987 if(!isWasmInitialized) {
40988 throw new Error("initializeWasm() must be awaited first!");
40990 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
40991 return nativeResponseValue;
40993 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
40995 export function InitFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
40996 if(!isWasmInitialized) {
40997 throw new Error("initializeWasm() must be awaited first!");
40999 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
41000 return nativeResponseValue;
41002 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41004 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
41005 if(!isWasmInitialized) {
41006 throw new Error("initializeWasm() must be awaited first!");
41008 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
41009 return nativeResponseValue;
41011 // void InitFeatures_set_taproot_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
41013 export function InitFeatures_set_taproot_optional(this_arg: bigint): void {
41014 if(!isWasmInitialized) {
41015 throw new Error("initializeWasm() must be awaited first!");
41017 const nativeResponseValue = wasm.TS_InitFeatures_set_taproot_optional(this_arg);
41018 // debug statements here
41020 // void InitFeatures_set_taproot_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
41022 export function InitFeatures_set_taproot_required(this_arg: bigint): void {
41023 if(!isWasmInitialized) {
41024 throw new Error("initializeWasm() must be awaited first!");
41026 const nativeResponseValue = wasm.TS_InitFeatures_set_taproot_required(this_arg);
41027 // debug statements here
41029 // MUST_USE_RES bool InitFeatures_supports_taproot(const struct LDKInitFeatures *NONNULL_PTR this_arg);
41031 export function InitFeatures_supports_taproot(this_arg: bigint): boolean {
41032 if(!isWasmInitialized) {
41033 throw new Error("initializeWasm() must be awaited first!");
41035 const nativeResponseValue = wasm.TS_InitFeatures_supports_taproot(this_arg);
41036 return nativeResponseValue;
41038 // void NodeFeatures_set_taproot_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41040 export function NodeFeatures_set_taproot_optional(this_arg: bigint): void {
41041 if(!isWasmInitialized) {
41042 throw new Error("initializeWasm() must be awaited first!");
41044 const nativeResponseValue = wasm.TS_NodeFeatures_set_taproot_optional(this_arg);
41045 // debug statements here
41047 // void NodeFeatures_set_taproot_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41049 export function NodeFeatures_set_taproot_required(this_arg: bigint): void {
41050 if(!isWasmInitialized) {
41051 throw new Error("initializeWasm() must be awaited first!");
41053 const nativeResponseValue = wasm.TS_NodeFeatures_set_taproot_required(this_arg);
41054 // debug statements here
41056 // MUST_USE_RES bool NodeFeatures_supports_taproot(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41058 export function NodeFeatures_supports_taproot(this_arg: bigint): boolean {
41059 if(!isWasmInitialized) {
41060 throw new Error("initializeWasm() must be awaited first!");
41062 const nativeResponseValue = wasm.TS_NodeFeatures_supports_taproot(this_arg);
41063 return nativeResponseValue;
41065 // void ChannelTypeFeatures_set_taproot_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41067 export function ChannelTypeFeatures_set_taproot_optional(this_arg: bigint): void {
41068 if(!isWasmInitialized) {
41069 throw new Error("initializeWasm() must be awaited first!");
41071 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_taproot_optional(this_arg);
41072 // debug statements here
41074 // void ChannelTypeFeatures_set_taproot_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41076 export function ChannelTypeFeatures_set_taproot_required(this_arg: bigint): void {
41077 if(!isWasmInitialized) {
41078 throw new Error("initializeWasm() must be awaited first!");
41080 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_taproot_required(this_arg);
41081 // debug statements here
41083 // MUST_USE_RES bool ChannelTypeFeatures_supports_taproot(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41085 export function ChannelTypeFeatures_supports_taproot(this_arg: bigint): boolean {
41086 if(!isWasmInitialized) {
41087 throw new Error("initializeWasm() must be awaited first!");
41089 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_taproot(this_arg);
41090 return nativeResponseValue;
41092 // MUST_USE_RES bool InitFeatures_requires_taproot(const struct LDKInitFeatures *NONNULL_PTR this_arg);
41094 export function InitFeatures_requires_taproot(this_arg: bigint): boolean {
41095 if(!isWasmInitialized) {
41096 throw new Error("initializeWasm() must be awaited first!");
41098 const nativeResponseValue = wasm.TS_InitFeatures_requires_taproot(this_arg);
41099 return nativeResponseValue;
41101 // MUST_USE_RES bool NodeFeatures_requires_taproot(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41103 export function NodeFeatures_requires_taproot(this_arg: bigint): boolean {
41104 if(!isWasmInitialized) {
41105 throw new Error("initializeWasm() must be awaited first!");
41107 const nativeResponseValue = wasm.TS_NodeFeatures_requires_taproot(this_arg);
41108 return nativeResponseValue;
41110 // MUST_USE_RES bool ChannelTypeFeatures_requires_taproot(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41112 export function ChannelTypeFeatures_requires_taproot(this_arg: bigint): boolean {
41113 if(!isWasmInitialized) {
41114 throw new Error("initializeWasm() must be awaited first!");
41116 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_taproot(this_arg);
41117 return nativeResponseValue;
41119 // void InitFeatures_set_onion_messages_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
41121 export function InitFeatures_set_onion_messages_optional(this_arg: bigint): void {
41122 if(!isWasmInitialized) {
41123 throw new Error("initializeWasm() must be awaited first!");
41125 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_optional(this_arg);
41126 // debug statements here
41128 // void InitFeatures_set_onion_messages_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
41130 export function InitFeatures_set_onion_messages_required(this_arg: bigint): void {
41131 if(!isWasmInitialized) {
41132 throw new Error("initializeWasm() must be awaited first!");
41134 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_required(this_arg);
41135 // debug statements here
41137 // MUST_USE_RES bool InitFeatures_supports_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
41139 export function InitFeatures_supports_onion_messages(this_arg: bigint): boolean {
41140 if(!isWasmInitialized) {
41141 throw new Error("initializeWasm() must be awaited first!");
41143 const nativeResponseValue = wasm.TS_InitFeatures_supports_onion_messages(this_arg);
41144 return nativeResponseValue;
41146 // void NodeFeatures_set_onion_messages_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41148 export function NodeFeatures_set_onion_messages_optional(this_arg: bigint): void {
41149 if(!isWasmInitialized) {
41150 throw new Error("initializeWasm() must be awaited first!");
41152 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_optional(this_arg);
41153 // debug statements here
41155 // void NodeFeatures_set_onion_messages_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41157 export function NodeFeatures_set_onion_messages_required(this_arg: bigint): void {
41158 if(!isWasmInitialized) {
41159 throw new Error("initializeWasm() must be awaited first!");
41161 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_required(this_arg);
41162 // debug statements here
41164 // MUST_USE_RES bool NodeFeatures_supports_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41166 export function NodeFeatures_supports_onion_messages(this_arg: bigint): boolean {
41167 if(!isWasmInitialized) {
41168 throw new Error("initializeWasm() must be awaited first!");
41170 const nativeResponseValue = wasm.TS_NodeFeatures_supports_onion_messages(this_arg);
41171 return nativeResponseValue;
41173 // MUST_USE_RES bool InitFeatures_requires_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
41175 export function InitFeatures_requires_onion_messages(this_arg: bigint): boolean {
41176 if(!isWasmInitialized) {
41177 throw new Error("initializeWasm() must be awaited first!");
41179 const nativeResponseValue = wasm.TS_InitFeatures_requires_onion_messages(this_arg);
41180 return nativeResponseValue;
41182 // MUST_USE_RES bool NodeFeatures_requires_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41184 export function NodeFeatures_requires_onion_messages(this_arg: bigint): boolean {
41185 if(!isWasmInitialized) {
41186 throw new Error("initializeWasm() must be awaited first!");
41188 const nativeResponseValue = wasm.TS_NodeFeatures_requires_onion_messages(this_arg);
41189 return nativeResponseValue;
41191 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
41193 export function InitFeatures_set_channel_type_optional(this_arg: bigint): void {
41194 if(!isWasmInitialized) {
41195 throw new Error("initializeWasm() must be awaited first!");
41197 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
41198 // debug statements here
41200 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
41202 export function InitFeatures_set_channel_type_required(this_arg: bigint): void {
41203 if(!isWasmInitialized) {
41204 throw new Error("initializeWasm() must be awaited first!");
41206 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
41207 // debug statements here
41209 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
41211 export function InitFeatures_supports_channel_type(this_arg: bigint): boolean {
41212 if(!isWasmInitialized) {
41213 throw new Error("initializeWasm() must be awaited first!");
41215 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
41216 return nativeResponseValue;
41218 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41220 export function NodeFeatures_set_channel_type_optional(this_arg: bigint): void {
41221 if(!isWasmInitialized) {
41222 throw new Error("initializeWasm() must be awaited first!");
41224 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
41225 // debug statements here
41227 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41229 export function NodeFeatures_set_channel_type_required(this_arg: bigint): void {
41230 if(!isWasmInitialized) {
41231 throw new Error("initializeWasm() must be awaited first!");
41233 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
41234 // debug statements here
41236 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41238 export function NodeFeatures_supports_channel_type(this_arg: bigint): boolean {
41239 if(!isWasmInitialized) {
41240 throw new Error("initializeWasm() must be awaited first!");
41242 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
41243 return nativeResponseValue;
41245 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
41247 export function InitFeatures_requires_channel_type(this_arg: bigint): boolean {
41248 if(!isWasmInitialized) {
41249 throw new Error("initializeWasm() must be awaited first!");
41251 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
41252 return nativeResponseValue;
41254 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41256 export function NodeFeatures_requires_channel_type(this_arg: bigint): boolean {
41257 if(!isWasmInitialized) {
41258 throw new Error("initializeWasm() must be awaited first!");
41260 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
41261 return nativeResponseValue;
41263 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
41265 export function InitFeatures_set_scid_privacy_optional(this_arg: bigint): void {
41266 if(!isWasmInitialized) {
41267 throw new Error("initializeWasm() must be awaited first!");
41269 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
41270 // debug statements here
41272 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
41274 export function InitFeatures_set_scid_privacy_required(this_arg: bigint): void {
41275 if(!isWasmInitialized) {
41276 throw new Error("initializeWasm() must be awaited first!");
41278 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
41279 // debug statements here
41281 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
41283 export function InitFeatures_supports_scid_privacy(this_arg: bigint): boolean {
41284 if(!isWasmInitialized) {
41285 throw new Error("initializeWasm() must be awaited first!");
41287 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
41288 return nativeResponseValue;
41290 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41292 export function NodeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
41293 if(!isWasmInitialized) {
41294 throw new Error("initializeWasm() must be awaited first!");
41296 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
41297 // debug statements here
41299 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41301 export function NodeFeatures_set_scid_privacy_required(this_arg: bigint): void {
41302 if(!isWasmInitialized) {
41303 throw new Error("initializeWasm() must be awaited first!");
41305 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
41306 // debug statements here
41308 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41310 export function NodeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
41311 if(!isWasmInitialized) {
41312 throw new Error("initializeWasm() must be awaited first!");
41314 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
41315 return nativeResponseValue;
41317 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41319 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
41320 if(!isWasmInitialized) {
41321 throw new Error("initializeWasm() must be awaited first!");
41323 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
41324 // debug statements here
41326 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41328 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: bigint): void {
41329 if(!isWasmInitialized) {
41330 throw new Error("initializeWasm() must be awaited first!");
41332 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
41333 // debug statements here
41335 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41337 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
41338 if(!isWasmInitialized) {
41339 throw new Error("initializeWasm() must be awaited first!");
41341 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
41342 return nativeResponseValue;
41344 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
41346 export function InitFeatures_requires_scid_privacy(this_arg: bigint): boolean {
41347 if(!isWasmInitialized) {
41348 throw new Error("initializeWasm() must be awaited first!");
41350 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
41351 return nativeResponseValue;
41353 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41355 export function NodeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
41356 if(!isWasmInitialized) {
41357 throw new Error("initializeWasm() must be awaited first!");
41359 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
41360 return nativeResponseValue;
41362 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41364 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
41365 if(!isWasmInitialized) {
41366 throw new Error("initializeWasm() must be awaited first!");
41368 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
41369 return nativeResponseValue;
41371 // void Bolt11InvoiceFeatures_set_payment_metadata_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
41373 export function Bolt11InvoiceFeatures_set_payment_metadata_optional(this_arg: bigint): void {
41374 if(!isWasmInitialized) {
41375 throw new Error("initializeWasm() must be awaited first!");
41377 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_metadata_optional(this_arg);
41378 // debug statements here
41380 // void Bolt11InvoiceFeatures_set_payment_metadata_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
41382 export function Bolt11InvoiceFeatures_set_payment_metadata_required(this_arg: bigint): void {
41383 if(!isWasmInitialized) {
41384 throw new Error("initializeWasm() must be awaited first!");
41386 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_metadata_required(this_arg);
41387 // debug statements here
41389 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_payment_metadata(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
41391 export function Bolt11InvoiceFeatures_supports_payment_metadata(this_arg: bigint): boolean {
41392 if(!isWasmInitialized) {
41393 throw new Error("initializeWasm() must be awaited first!");
41395 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_payment_metadata(this_arg);
41396 return nativeResponseValue;
41398 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_payment_metadata(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
41400 export function Bolt11InvoiceFeatures_requires_payment_metadata(this_arg: bigint): boolean {
41401 if(!isWasmInitialized) {
41402 throw new Error("initializeWasm() must be awaited first!");
41404 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_payment_metadata(this_arg);
41405 return nativeResponseValue;
41407 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
41409 export function InitFeatures_set_zero_conf_optional(this_arg: bigint): void {
41410 if(!isWasmInitialized) {
41411 throw new Error("initializeWasm() must be awaited first!");
41413 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
41414 // debug statements here
41416 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
41418 export function InitFeatures_set_zero_conf_required(this_arg: bigint): void {
41419 if(!isWasmInitialized) {
41420 throw new Error("initializeWasm() must be awaited first!");
41422 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
41423 // debug statements here
41425 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
41427 export function InitFeatures_supports_zero_conf(this_arg: bigint): boolean {
41428 if(!isWasmInitialized) {
41429 throw new Error("initializeWasm() must be awaited first!");
41431 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
41432 return nativeResponseValue;
41434 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41436 export function NodeFeatures_set_zero_conf_optional(this_arg: bigint): void {
41437 if(!isWasmInitialized) {
41438 throw new Error("initializeWasm() must be awaited first!");
41440 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
41441 // debug statements here
41443 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41445 export function NodeFeatures_set_zero_conf_required(this_arg: bigint): void {
41446 if(!isWasmInitialized) {
41447 throw new Error("initializeWasm() must be awaited first!");
41449 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
41450 // debug statements here
41452 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41454 export function NodeFeatures_supports_zero_conf(this_arg: bigint): boolean {
41455 if(!isWasmInitialized) {
41456 throw new Error("initializeWasm() must be awaited first!");
41458 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
41459 return nativeResponseValue;
41461 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41463 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: bigint): void {
41464 if(!isWasmInitialized) {
41465 throw new Error("initializeWasm() must be awaited first!");
41467 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
41468 // debug statements here
41470 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41472 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: bigint): void {
41473 if(!isWasmInitialized) {
41474 throw new Error("initializeWasm() must be awaited first!");
41476 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
41477 // debug statements here
41479 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41481 export function ChannelTypeFeatures_supports_zero_conf(this_arg: bigint): boolean {
41482 if(!isWasmInitialized) {
41483 throw new Error("initializeWasm() must be awaited first!");
41485 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
41486 return nativeResponseValue;
41488 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
41490 export function InitFeatures_requires_zero_conf(this_arg: bigint): boolean {
41491 if(!isWasmInitialized) {
41492 throw new Error("initializeWasm() must be awaited first!");
41494 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
41495 return nativeResponseValue;
41497 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41499 export function NodeFeatures_requires_zero_conf(this_arg: bigint): boolean {
41500 if(!isWasmInitialized) {
41501 throw new Error("initializeWasm() must be awaited first!");
41503 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
41504 return nativeResponseValue;
41506 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
41508 export function ChannelTypeFeatures_requires_zero_conf(this_arg: bigint): boolean {
41509 if(!isWasmInitialized) {
41510 throw new Error("initializeWasm() must be awaited first!");
41512 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
41513 return nativeResponseValue;
41515 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41517 export function NodeFeatures_set_keysend_optional(this_arg: bigint): void {
41518 if(!isWasmInitialized) {
41519 throw new Error("initializeWasm() must be awaited first!");
41521 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
41522 // debug statements here
41524 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
41526 export function NodeFeatures_set_keysend_required(this_arg: bigint): void {
41527 if(!isWasmInitialized) {
41528 throw new Error("initializeWasm() must be awaited first!");
41530 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
41531 // debug statements here
41533 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41535 export function NodeFeatures_supports_keysend(this_arg: bigint): boolean {
41536 if(!isWasmInitialized) {
41537 throw new Error("initializeWasm() must be awaited first!");
41539 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
41540 return nativeResponseValue;
41542 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
41544 export function NodeFeatures_requires_keysend(this_arg: bigint): boolean {
41545 if(!isWasmInitialized) {
41546 throw new Error("initializeWasm() must be awaited first!");
41548 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
41549 return nativeResponseValue;
41551 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
41553 export function ShutdownScript_free(this_obj: bigint): void {
41554 if(!isWasmInitialized) {
41555 throw new Error("initializeWasm() must be awaited first!");
41557 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
41558 // debug statements here
41560 // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
41562 export function ShutdownScript_clone_ptr(arg: bigint): bigint {
41563 if(!isWasmInitialized) {
41564 throw new Error("initializeWasm() must be awaited first!");
41566 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
41567 return nativeResponseValue;
41569 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
41571 export function ShutdownScript_clone(orig: bigint): bigint {
41572 if(!isWasmInitialized) {
41573 throw new Error("initializeWasm() must be awaited first!");
41575 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
41576 return nativeResponseValue;
41578 // bool ShutdownScript_eq(const struct LDKShutdownScript *NONNULL_PTR a, const struct LDKShutdownScript *NONNULL_PTR b);
41580 export function ShutdownScript_eq(a: bigint, b: bigint): boolean {
41581 if(!isWasmInitialized) {
41582 throw new Error("initializeWasm() must be awaited first!");
41584 const nativeResponseValue = wasm.TS_ShutdownScript_eq(a, b);
41585 return nativeResponseValue;
41587 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
41589 export function InvalidShutdownScript_free(this_obj: bigint): void {
41590 if(!isWasmInitialized) {
41591 throw new Error("initializeWasm() must be awaited first!");
41593 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
41594 // debug statements here
41596 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
41598 export function InvalidShutdownScript_get_script(this_ptr: bigint): number {
41599 if(!isWasmInitialized) {
41600 throw new Error("initializeWasm() must be awaited first!");
41602 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
41603 return nativeResponseValue;
41605 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
41607 export function InvalidShutdownScript_set_script(this_ptr: bigint, val: number): void {
41608 if(!isWasmInitialized) {
41609 throw new Error("initializeWasm() must be awaited first!");
41611 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
41612 // debug statements here
41614 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
41616 export function InvalidShutdownScript_new(script_arg: number): bigint {
41617 if(!isWasmInitialized) {
41618 throw new Error("initializeWasm() must be awaited first!");
41620 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
41621 return nativeResponseValue;
41623 // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
41625 export function InvalidShutdownScript_clone_ptr(arg: bigint): bigint {
41626 if(!isWasmInitialized) {
41627 throw new Error("initializeWasm() must be awaited first!");
41629 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
41630 return nativeResponseValue;
41632 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
41634 export function InvalidShutdownScript_clone(orig: bigint): bigint {
41635 if(!isWasmInitialized) {
41636 throw new Error("initializeWasm() must be awaited first!");
41638 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
41639 return nativeResponseValue;
41641 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
41643 export function ShutdownScript_write(obj: bigint): number {
41644 if(!isWasmInitialized) {
41645 throw new Error("initializeWasm() must be awaited first!");
41647 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
41648 return nativeResponseValue;
41650 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
41652 export function ShutdownScript_read(ser: number): bigint {
41653 if(!isWasmInitialized) {
41654 throw new Error("initializeWasm() must be awaited first!");
41656 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
41657 return nativeResponseValue;
41659 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
41661 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): bigint {
41662 if(!isWasmInitialized) {
41663 throw new Error("initializeWasm() must be awaited first!");
41665 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
41666 return nativeResponseValue;
41668 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
41670 export function ShutdownScript_new_p2wsh(script_hash: number): bigint {
41671 if(!isWasmInitialized) {
41672 throw new Error("initializeWasm() must be awaited first!");
41674 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
41675 return nativeResponseValue;
41677 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
41679 export function ShutdownScript_new_witness_program(version: number, program: number): bigint {
41680 if(!isWasmInitialized) {
41681 throw new Error("initializeWasm() must be awaited first!");
41683 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
41684 return nativeResponseValue;
41686 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
41688 export function ShutdownScript_into_inner(this_arg: bigint): number {
41689 if(!isWasmInitialized) {
41690 throw new Error("initializeWasm() must be awaited first!");
41692 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
41693 return nativeResponseValue;
41695 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
41697 export function ShutdownScript_as_legacy_pubkey(this_arg: bigint): number {
41698 if(!isWasmInitialized) {
41699 throw new Error("initializeWasm() must be awaited first!");
41701 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
41702 return nativeResponseValue;
41704 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
41706 export function ShutdownScript_is_compatible(this_arg: bigint, features: bigint): boolean {
41707 if(!isWasmInitialized) {
41708 throw new Error("initializeWasm() must be awaited first!");
41710 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
41711 return nativeResponseValue;
41713 // void Retry_free(struct LDKRetry this_ptr);
41715 export function Retry_free(this_ptr: bigint): void {
41716 if(!isWasmInitialized) {
41717 throw new Error("initializeWasm() must be awaited first!");
41719 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
41720 // debug statements here
41722 // uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
41724 export function Retry_clone_ptr(arg: bigint): bigint {
41725 if(!isWasmInitialized) {
41726 throw new Error("initializeWasm() must be awaited first!");
41728 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
41729 return nativeResponseValue;
41731 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
41733 export function Retry_clone(orig: bigint): bigint {
41734 if(!isWasmInitialized) {
41735 throw new Error("initializeWasm() must be awaited first!");
41737 const nativeResponseValue = wasm.TS_Retry_clone(orig);
41738 return nativeResponseValue;
41740 // struct LDKRetry Retry_attempts(uint32_t a);
41742 export function Retry_attempts(a: number): bigint {
41743 if(!isWasmInitialized) {
41744 throw new Error("initializeWasm() must be awaited first!");
41746 const nativeResponseValue = wasm.TS_Retry_attempts(a);
41747 return nativeResponseValue;
41749 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
41751 export function Retry_eq(a: bigint, b: bigint): boolean {
41752 if(!isWasmInitialized) {
41753 throw new Error("initializeWasm() must be awaited first!");
41755 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
41756 return nativeResponseValue;
41758 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
41760 export function Retry_hash(o: bigint): bigint {
41761 if(!isWasmInitialized) {
41762 throw new Error("initializeWasm() must be awaited first!");
41764 const nativeResponseValue = wasm.TS_Retry_hash(o);
41765 return nativeResponseValue;
41767 // struct LDKCVec_u8Z Retry_write(const struct LDKRetry *NONNULL_PTR obj);
41769 export function Retry_write(obj: bigint): number {
41770 if(!isWasmInitialized) {
41771 throw new Error("initializeWasm() must be awaited first!");
41773 const nativeResponseValue = wasm.TS_Retry_write(obj);
41774 return nativeResponseValue;
41776 // struct LDKCResult_RetryDecodeErrorZ Retry_read(struct LDKu8slice ser);
41778 export function Retry_read(ser: number): bigint {
41779 if(!isWasmInitialized) {
41780 throw new Error("initializeWasm() must be awaited first!");
41782 const nativeResponseValue = wasm.TS_Retry_read(ser);
41783 return nativeResponseValue;
41785 // enum LDKRetryableSendFailure RetryableSendFailure_clone(const enum LDKRetryableSendFailure *NONNULL_PTR orig);
41787 export function RetryableSendFailure_clone(orig: bigint): RetryableSendFailure {
41788 if(!isWasmInitialized) {
41789 throw new Error("initializeWasm() must be awaited first!");
41791 const nativeResponseValue = wasm.TS_RetryableSendFailure_clone(orig);
41792 return nativeResponseValue;
41794 // enum LDKRetryableSendFailure RetryableSendFailure_payment_expired(void);
41796 export function RetryableSendFailure_payment_expired(): RetryableSendFailure {
41797 if(!isWasmInitialized) {
41798 throw new Error("initializeWasm() must be awaited first!");
41800 const nativeResponseValue = wasm.TS_RetryableSendFailure_payment_expired();
41801 return nativeResponseValue;
41803 // enum LDKRetryableSendFailure RetryableSendFailure_route_not_found(void);
41805 export function RetryableSendFailure_route_not_found(): RetryableSendFailure {
41806 if(!isWasmInitialized) {
41807 throw new Error("initializeWasm() must be awaited first!");
41809 const nativeResponseValue = wasm.TS_RetryableSendFailure_route_not_found();
41810 return nativeResponseValue;
41812 // enum LDKRetryableSendFailure RetryableSendFailure_duplicate_payment(void);
41814 export function RetryableSendFailure_duplicate_payment(): RetryableSendFailure {
41815 if(!isWasmInitialized) {
41816 throw new Error("initializeWasm() must be awaited first!");
41818 const nativeResponseValue = wasm.TS_RetryableSendFailure_duplicate_payment();
41819 return nativeResponseValue;
41821 // bool RetryableSendFailure_eq(const enum LDKRetryableSendFailure *NONNULL_PTR a, const enum LDKRetryableSendFailure *NONNULL_PTR b);
41823 export function RetryableSendFailure_eq(a: bigint, b: bigint): boolean {
41824 if(!isWasmInitialized) {
41825 throw new Error("initializeWasm() must be awaited first!");
41827 const nativeResponseValue = wasm.TS_RetryableSendFailure_eq(a, b);
41828 return nativeResponseValue;
41830 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
41832 export function PaymentSendFailure_free(this_ptr: bigint): void {
41833 if(!isWasmInitialized) {
41834 throw new Error("initializeWasm() must be awaited first!");
41836 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
41837 // debug statements here
41839 // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
41841 export function PaymentSendFailure_clone_ptr(arg: bigint): bigint {
41842 if(!isWasmInitialized) {
41843 throw new Error("initializeWasm() must be awaited first!");
41845 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
41846 return nativeResponseValue;
41848 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
41850 export function PaymentSendFailure_clone(orig: bigint): bigint {
41851 if(!isWasmInitialized) {
41852 throw new Error("initializeWasm() must be awaited first!");
41854 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
41855 return nativeResponseValue;
41857 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
41859 export function PaymentSendFailure_parameter_error(a: bigint): bigint {
41860 if(!isWasmInitialized) {
41861 throw new Error("initializeWasm() must be awaited first!");
41863 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
41864 return nativeResponseValue;
41866 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
41868 export function PaymentSendFailure_path_parameter_error(a: number): bigint {
41869 if(!isWasmInitialized) {
41870 throw new Error("initializeWasm() must be awaited first!");
41872 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
41873 return nativeResponseValue;
41875 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_resend_safe(struct LDKCVec_APIErrorZ a);
41877 export function PaymentSendFailure_all_failed_resend_safe(a: number): bigint {
41878 if(!isWasmInitialized) {
41879 throw new Error("initializeWasm() must be awaited first!");
41881 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_resend_safe(a);
41882 return nativeResponseValue;
41884 // struct LDKPaymentSendFailure PaymentSendFailure_duplicate_payment(void);
41886 export function PaymentSendFailure_duplicate_payment(): bigint {
41887 if(!isWasmInitialized) {
41888 throw new Error("initializeWasm() must be awaited first!");
41890 const nativeResponseValue = wasm.TS_PaymentSendFailure_duplicate_payment();
41891 return nativeResponseValue;
41893 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
41895 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: bigint, payment_id: number): bigint {
41896 if(!isWasmInitialized) {
41897 throw new Error("initializeWasm() must be awaited first!");
41899 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
41900 return nativeResponseValue;
41902 // bool PaymentSendFailure_eq(const struct LDKPaymentSendFailure *NONNULL_PTR a, const struct LDKPaymentSendFailure *NONNULL_PTR b);
41904 export function PaymentSendFailure_eq(a: bigint, b: bigint): boolean {
41905 if(!isWasmInitialized) {
41906 throw new Error("initializeWasm() must be awaited first!");
41908 const nativeResponseValue = wasm.TS_PaymentSendFailure_eq(a, b);
41909 return nativeResponseValue;
41911 // void ProbeSendFailure_free(struct LDKProbeSendFailure this_ptr);
41913 export function ProbeSendFailure_free(this_ptr: bigint): void {
41914 if(!isWasmInitialized) {
41915 throw new Error("initializeWasm() must be awaited first!");
41917 const nativeResponseValue = wasm.TS_ProbeSendFailure_free(this_ptr);
41918 // debug statements here
41920 // uint64_t ProbeSendFailure_clone_ptr(LDKProbeSendFailure *NONNULL_PTR arg);
41922 export function ProbeSendFailure_clone_ptr(arg: bigint): bigint {
41923 if(!isWasmInitialized) {
41924 throw new Error("initializeWasm() must be awaited first!");
41926 const nativeResponseValue = wasm.TS_ProbeSendFailure_clone_ptr(arg);
41927 return nativeResponseValue;
41929 // struct LDKProbeSendFailure ProbeSendFailure_clone(const struct LDKProbeSendFailure *NONNULL_PTR orig);
41931 export function ProbeSendFailure_clone(orig: bigint): bigint {
41932 if(!isWasmInitialized) {
41933 throw new Error("initializeWasm() must be awaited first!");
41935 const nativeResponseValue = wasm.TS_ProbeSendFailure_clone(orig);
41936 return nativeResponseValue;
41938 // struct LDKProbeSendFailure ProbeSendFailure_route_not_found(void);
41940 export function ProbeSendFailure_route_not_found(): bigint {
41941 if(!isWasmInitialized) {
41942 throw new Error("initializeWasm() must be awaited first!");
41944 const nativeResponseValue = wasm.TS_ProbeSendFailure_route_not_found();
41945 return nativeResponseValue;
41947 // struct LDKProbeSendFailure ProbeSendFailure_sending_failed(struct LDKPaymentSendFailure a);
41949 export function ProbeSendFailure_sending_failed(a: bigint): bigint {
41950 if(!isWasmInitialized) {
41951 throw new Error("initializeWasm() must be awaited first!");
41953 const nativeResponseValue = wasm.TS_ProbeSendFailure_sending_failed(a);
41954 return nativeResponseValue;
41956 // bool ProbeSendFailure_eq(const struct LDKProbeSendFailure *NONNULL_PTR a, const struct LDKProbeSendFailure *NONNULL_PTR b);
41958 export function ProbeSendFailure_eq(a: bigint, b: bigint): boolean {
41959 if(!isWasmInitialized) {
41960 throw new Error("initializeWasm() must be awaited first!");
41962 const nativeResponseValue = wasm.TS_ProbeSendFailure_eq(a, b);
41963 return nativeResponseValue;
41965 // void RecipientOnionFields_free(struct LDKRecipientOnionFields this_obj);
41967 export function RecipientOnionFields_free(this_obj: bigint): void {
41968 if(!isWasmInitialized) {
41969 throw new Error("initializeWasm() must be awaited first!");
41971 const nativeResponseValue = wasm.TS_RecipientOnionFields_free(this_obj);
41972 // debug statements here
41974 // struct LDKCOption_ThirtyTwoBytesZ RecipientOnionFields_get_payment_secret(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
41976 export function RecipientOnionFields_get_payment_secret(this_ptr: bigint): bigint {
41977 if(!isWasmInitialized) {
41978 throw new Error("initializeWasm() must be awaited first!");
41980 const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_secret(this_ptr);
41981 return nativeResponseValue;
41983 // void RecipientOnionFields_set_payment_secret(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
41985 export function RecipientOnionFields_set_payment_secret(this_ptr: bigint, val: bigint): void {
41986 if(!isWasmInitialized) {
41987 throw new Error("initializeWasm() must be awaited first!");
41989 const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_secret(this_ptr, val);
41990 // debug statements here
41992 // struct LDKCOption_CVec_u8ZZ RecipientOnionFields_get_payment_metadata(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
41994 export function RecipientOnionFields_get_payment_metadata(this_ptr: bigint): bigint {
41995 if(!isWasmInitialized) {
41996 throw new Error("initializeWasm() must be awaited first!");
41998 const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_metadata(this_ptr);
41999 return nativeResponseValue;
42001 // void RecipientOnionFields_set_payment_metadata(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
42003 export function RecipientOnionFields_set_payment_metadata(this_ptr: bigint, val: bigint): void {
42004 if(!isWasmInitialized) {
42005 throw new Error("initializeWasm() must be awaited first!");
42007 const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_metadata(this_ptr, val);
42008 // debug statements here
42010 // uint64_t RecipientOnionFields_clone_ptr(LDKRecipientOnionFields *NONNULL_PTR arg);
42012 export function RecipientOnionFields_clone_ptr(arg: bigint): bigint {
42013 if(!isWasmInitialized) {
42014 throw new Error("initializeWasm() must be awaited first!");
42016 const nativeResponseValue = wasm.TS_RecipientOnionFields_clone_ptr(arg);
42017 return nativeResponseValue;
42019 // struct LDKRecipientOnionFields RecipientOnionFields_clone(const struct LDKRecipientOnionFields *NONNULL_PTR orig);
42021 export function RecipientOnionFields_clone(orig: bigint): bigint {
42022 if(!isWasmInitialized) {
42023 throw new Error("initializeWasm() must be awaited first!");
42025 const nativeResponseValue = wasm.TS_RecipientOnionFields_clone(orig);
42026 return nativeResponseValue;
42028 // bool RecipientOnionFields_eq(const struct LDKRecipientOnionFields *NONNULL_PTR a, const struct LDKRecipientOnionFields *NONNULL_PTR b);
42030 export function RecipientOnionFields_eq(a: bigint, b: bigint): boolean {
42031 if(!isWasmInitialized) {
42032 throw new Error("initializeWasm() must be awaited first!");
42034 const nativeResponseValue = wasm.TS_RecipientOnionFields_eq(a, b);
42035 return nativeResponseValue;
42037 // struct LDKCVec_u8Z RecipientOnionFields_write(const struct LDKRecipientOnionFields *NONNULL_PTR obj);
42039 export function RecipientOnionFields_write(obj: bigint): number {
42040 if(!isWasmInitialized) {
42041 throw new Error("initializeWasm() must be awaited first!");
42043 const nativeResponseValue = wasm.TS_RecipientOnionFields_write(obj);
42044 return nativeResponseValue;
42046 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ RecipientOnionFields_read(struct LDKu8slice ser);
42048 export function RecipientOnionFields_read(ser: number): bigint {
42049 if(!isWasmInitialized) {
42050 throw new Error("initializeWasm() must be awaited first!");
42052 const nativeResponseValue = wasm.TS_RecipientOnionFields_read(ser);
42053 return nativeResponseValue;
42055 // MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_secret_only(struct LDKThirtyTwoBytes payment_secret);
42057 export function RecipientOnionFields_secret_only(payment_secret: number): bigint {
42058 if(!isWasmInitialized) {
42059 throw new Error("initializeWasm() must be awaited first!");
42061 const nativeResponseValue = wasm.TS_RecipientOnionFields_secret_only(payment_secret);
42062 return nativeResponseValue;
42064 // MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_spontaneous_empty(void);
42066 export function RecipientOnionFields_spontaneous_empty(): bigint {
42067 if(!isWasmInitialized) {
42068 throw new Error("initializeWasm() must be awaited first!");
42070 const nativeResponseValue = wasm.TS_RecipientOnionFields_spontaneous_empty();
42071 return nativeResponseValue;
42073 // MUST_USE_RES struct LDKCResult_RecipientOnionFieldsNoneZ RecipientOnionFields_with_custom_tlvs(struct LDKRecipientOnionFields this_arg, struct LDKCVec_C2Tuple_u64CVec_u8ZZZ custom_tlvs);
42075 export function RecipientOnionFields_with_custom_tlvs(this_arg: bigint, custom_tlvs: number): bigint {
42076 if(!isWasmInitialized) {
42077 throw new Error("initializeWasm() must be awaited first!");
42079 const nativeResponseValue = wasm.TS_RecipientOnionFields_with_custom_tlvs(this_arg, custom_tlvs);
42080 return nativeResponseValue;
42082 // MUST_USE_RES struct LDKCVec_C2Tuple_u64CVec_u8ZZZ RecipientOnionFields_custom_tlvs(const struct LDKRecipientOnionFields *NONNULL_PTR this_arg);
42084 export function RecipientOnionFields_custom_tlvs(this_arg: bigint): number {
42085 if(!isWasmInitialized) {
42086 throw new Error("initializeWasm() must be awaited first!");
42088 const nativeResponseValue = wasm.TS_RecipientOnionFields_custom_tlvs(this_arg);
42089 return nativeResponseValue;
42091 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
42093 export function CustomMessageReader_free(this_ptr: bigint): void {
42094 if(!isWasmInitialized) {
42095 throw new Error("initializeWasm() must be awaited first!");
42097 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
42098 // debug statements here
42100 // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
42102 export function Type_clone_ptr(arg: bigint): bigint {
42103 if(!isWasmInitialized) {
42104 throw new Error("initializeWasm() must be awaited first!");
42106 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
42107 return nativeResponseValue;
42109 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
42111 export function Type_clone(orig: bigint): bigint {
42112 if(!isWasmInitialized) {
42113 throw new Error("initializeWasm() must be awaited first!");
42115 const nativeResponseValue = wasm.TS_Type_clone(orig);
42116 return nativeResponseValue;
42118 // void Type_free(struct LDKType this_ptr);
42120 export function Type_free(this_ptr: bigint): void {
42121 if(!isWasmInitialized) {
42122 throw new Error("initializeWasm() must be awaited first!");
42124 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
42125 // debug statements here
42127 // void Offer_free(struct LDKOffer this_obj);
42129 export function Offer_free(this_obj: bigint): void {
42130 if(!isWasmInitialized) {
42131 throw new Error("initializeWasm() must be awaited first!");
42133 const nativeResponseValue = wasm.TS_Offer_free(this_obj);
42134 // debug statements here
42136 // uint64_t Offer_clone_ptr(LDKOffer *NONNULL_PTR arg);
42138 export function Offer_clone_ptr(arg: bigint): bigint {
42139 if(!isWasmInitialized) {
42140 throw new Error("initializeWasm() must be awaited first!");
42142 const nativeResponseValue = wasm.TS_Offer_clone_ptr(arg);
42143 return nativeResponseValue;
42145 // struct LDKOffer Offer_clone(const struct LDKOffer *NONNULL_PTR orig);
42147 export function Offer_clone(orig: bigint): bigint {
42148 if(!isWasmInitialized) {
42149 throw new Error("initializeWasm() must be awaited first!");
42151 const nativeResponseValue = wasm.TS_Offer_clone(orig);
42152 return nativeResponseValue;
42154 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ Offer_chains(const struct LDKOffer *NONNULL_PTR this_arg);
42156 export function Offer_chains(this_arg: bigint): number {
42157 if(!isWasmInitialized) {
42158 throw new Error("initializeWasm() must be awaited first!");
42160 const nativeResponseValue = wasm.TS_Offer_chains(this_arg);
42161 return nativeResponseValue;
42163 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Offer_metadata(const struct LDKOffer *NONNULL_PTR this_arg);
42165 export function Offer_metadata(this_arg: bigint): bigint {
42166 if(!isWasmInitialized) {
42167 throw new Error("initializeWasm() must be awaited first!");
42169 const nativeResponseValue = wasm.TS_Offer_metadata(this_arg);
42170 return nativeResponseValue;
42172 // MUST_USE_RES struct LDKAmount Offer_amount(const struct LDKOffer *NONNULL_PTR this_arg);
42174 export function Offer_amount(this_arg: bigint): bigint {
42175 if(!isWasmInitialized) {
42176 throw new Error("initializeWasm() must be awaited first!");
42178 const nativeResponseValue = wasm.TS_Offer_amount(this_arg);
42179 return nativeResponseValue;
42181 // MUST_USE_RES struct LDKPrintableString Offer_description(const struct LDKOffer *NONNULL_PTR this_arg);
42183 export function Offer_description(this_arg: bigint): bigint {
42184 if(!isWasmInitialized) {
42185 throw new Error("initializeWasm() must be awaited first!");
42187 const nativeResponseValue = wasm.TS_Offer_description(this_arg);
42188 return nativeResponseValue;
42190 // MUST_USE_RES struct LDKOfferFeatures Offer_offer_features(const struct LDKOffer *NONNULL_PTR this_arg);
42192 export function Offer_offer_features(this_arg: bigint): bigint {
42193 if(!isWasmInitialized) {
42194 throw new Error("initializeWasm() must be awaited first!");
42196 const nativeResponseValue = wasm.TS_Offer_offer_features(this_arg);
42197 return nativeResponseValue;
42199 // MUST_USE_RES struct LDKCOption_u64Z Offer_absolute_expiry(const struct LDKOffer *NONNULL_PTR this_arg);
42201 export function Offer_absolute_expiry(this_arg: bigint): bigint {
42202 if(!isWasmInitialized) {
42203 throw new Error("initializeWasm() must be awaited first!");
42205 const nativeResponseValue = wasm.TS_Offer_absolute_expiry(this_arg);
42206 return nativeResponseValue;
42208 // MUST_USE_RES struct LDKPrintableString Offer_issuer(const struct LDKOffer *NONNULL_PTR this_arg);
42210 export function Offer_issuer(this_arg: bigint): bigint {
42211 if(!isWasmInitialized) {
42212 throw new Error("initializeWasm() must be awaited first!");
42214 const nativeResponseValue = wasm.TS_Offer_issuer(this_arg);
42215 return nativeResponseValue;
42217 // MUST_USE_RES struct LDKCVec_BlindedPathZ Offer_paths(const struct LDKOffer *NONNULL_PTR this_arg);
42219 export function Offer_paths(this_arg: bigint): number {
42220 if(!isWasmInitialized) {
42221 throw new Error("initializeWasm() must be awaited first!");
42223 const nativeResponseValue = wasm.TS_Offer_paths(this_arg);
42224 return nativeResponseValue;
42226 // MUST_USE_RES struct LDKQuantity Offer_supported_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
42228 export function Offer_supported_quantity(this_arg: bigint): bigint {
42229 if(!isWasmInitialized) {
42230 throw new Error("initializeWasm() must be awaited first!");
42232 const nativeResponseValue = wasm.TS_Offer_supported_quantity(this_arg);
42233 return nativeResponseValue;
42235 // MUST_USE_RES struct LDKPublicKey Offer_signing_pubkey(const struct LDKOffer *NONNULL_PTR this_arg);
42237 export function Offer_signing_pubkey(this_arg: bigint): number {
42238 if(!isWasmInitialized) {
42239 throw new Error("initializeWasm() must be awaited first!");
42241 const nativeResponseValue = wasm.TS_Offer_signing_pubkey(this_arg);
42242 return nativeResponseValue;
42244 // MUST_USE_RES bool Offer_supports_chain(const struct LDKOffer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes chain);
42246 export function Offer_supports_chain(this_arg: bigint, chain: number): boolean {
42247 if(!isWasmInitialized) {
42248 throw new Error("initializeWasm() must be awaited first!");
42250 const nativeResponseValue = wasm.TS_Offer_supports_chain(this_arg, chain);
42251 return nativeResponseValue;
42253 // MUST_USE_RES bool Offer_is_valid_quantity(const struct LDKOffer *NONNULL_PTR this_arg, uint64_t quantity);
42255 export function Offer_is_valid_quantity(this_arg: bigint, quantity: bigint): boolean {
42256 if(!isWasmInitialized) {
42257 throw new Error("initializeWasm() must be awaited first!");
42259 const nativeResponseValue = wasm.TS_Offer_is_valid_quantity(this_arg, quantity);
42260 return nativeResponseValue;
42262 // MUST_USE_RES bool Offer_expects_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
42264 export function Offer_expects_quantity(this_arg: bigint): boolean {
42265 if(!isWasmInitialized) {
42266 throw new Error("initializeWasm() must be awaited first!");
42268 const nativeResponseValue = wasm.TS_Offer_expects_quantity(this_arg);
42269 return nativeResponseValue;
42271 // struct LDKCVec_u8Z Offer_write(const struct LDKOffer *NONNULL_PTR obj);
42273 export function Offer_write(obj: bigint): number {
42274 if(!isWasmInitialized) {
42275 throw new Error("initializeWasm() must be awaited first!");
42277 const nativeResponseValue = wasm.TS_Offer_write(obj);
42278 return nativeResponseValue;
42280 // void Amount_free(struct LDKAmount this_obj);
42282 export function Amount_free(this_obj: bigint): void {
42283 if(!isWasmInitialized) {
42284 throw new Error("initializeWasm() must be awaited first!");
42286 const nativeResponseValue = wasm.TS_Amount_free(this_obj);
42287 // debug statements here
42289 // uint64_t Amount_clone_ptr(LDKAmount *NONNULL_PTR arg);
42291 export function Amount_clone_ptr(arg: bigint): bigint {
42292 if(!isWasmInitialized) {
42293 throw new Error("initializeWasm() must be awaited first!");
42295 const nativeResponseValue = wasm.TS_Amount_clone_ptr(arg);
42296 return nativeResponseValue;
42298 // struct LDKAmount Amount_clone(const struct LDKAmount *NONNULL_PTR orig);
42300 export function Amount_clone(orig: bigint): bigint {
42301 if(!isWasmInitialized) {
42302 throw new Error("initializeWasm() must be awaited first!");
42304 const nativeResponseValue = wasm.TS_Amount_clone(orig);
42305 return nativeResponseValue;
42307 // void Quantity_free(struct LDKQuantity this_obj);
42309 export function Quantity_free(this_obj: bigint): void {
42310 if(!isWasmInitialized) {
42311 throw new Error("initializeWasm() must be awaited first!");
42313 const nativeResponseValue = wasm.TS_Quantity_free(this_obj);
42314 // debug statements here
42316 // uint64_t Quantity_clone_ptr(LDKQuantity *NONNULL_PTR arg);
42318 export function Quantity_clone_ptr(arg: bigint): bigint {
42319 if(!isWasmInitialized) {
42320 throw new Error("initializeWasm() must be awaited first!");
42322 const nativeResponseValue = wasm.TS_Quantity_clone_ptr(arg);
42323 return nativeResponseValue;
42325 // struct LDKQuantity Quantity_clone(const struct LDKQuantity *NONNULL_PTR orig);
42327 export function Quantity_clone(orig: bigint): bigint {
42328 if(!isWasmInitialized) {
42329 throw new Error("initializeWasm() must be awaited first!");
42331 const nativeResponseValue = wasm.TS_Quantity_clone(orig);
42332 return nativeResponseValue;
42334 // struct LDKCResult_OfferBolt12ParseErrorZ Offer_from_str(struct LDKStr s);
42336 export function Offer_from_str(s: number): bigint {
42337 if(!isWasmInitialized) {
42338 throw new Error("initializeWasm() must be awaited first!");
42340 const nativeResponseValue = wasm.TS_Offer_from_str(s);
42341 return nativeResponseValue;
42343 // void UnsignedBolt12Invoice_free(struct LDKUnsignedBolt12Invoice this_obj);
42345 export function UnsignedBolt12Invoice_free(this_obj: bigint): void {
42346 if(!isWasmInitialized) {
42347 throw new Error("initializeWasm() must be awaited first!");
42349 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_free(this_obj);
42350 // debug statements here
42352 // MUST_USE_RES struct LDKTaggedHash UnsignedBolt12Invoice_tagged_hash(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42354 export function UnsignedBolt12Invoice_tagged_hash(this_arg: bigint): bigint {
42355 if(!isWasmInitialized) {
42356 throw new Error("initializeWasm() must be awaited first!");
42358 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_tagged_hash(this_arg);
42359 return nativeResponseValue;
42361 // void Bolt12Invoice_free(struct LDKBolt12Invoice this_obj);
42363 export function Bolt12Invoice_free(this_obj: bigint): void {
42364 if(!isWasmInitialized) {
42365 throw new Error("initializeWasm() must be awaited first!");
42367 const nativeResponseValue = wasm.TS_Bolt12Invoice_free(this_obj);
42368 // debug statements here
42370 // uint64_t Bolt12Invoice_clone_ptr(LDKBolt12Invoice *NONNULL_PTR arg);
42372 export function Bolt12Invoice_clone_ptr(arg: bigint): bigint {
42373 if(!isWasmInitialized) {
42374 throw new Error("initializeWasm() must be awaited first!");
42376 const nativeResponseValue = wasm.TS_Bolt12Invoice_clone_ptr(arg);
42377 return nativeResponseValue;
42379 // struct LDKBolt12Invoice Bolt12Invoice_clone(const struct LDKBolt12Invoice *NONNULL_PTR orig);
42381 export function Bolt12Invoice_clone(orig: bigint): bigint {
42382 if(!isWasmInitialized) {
42383 throw new Error("initializeWasm() must be awaited first!");
42385 const nativeResponseValue = wasm.TS_Bolt12Invoice_clone(orig);
42386 return nativeResponseValue;
42388 // MUST_USE_RES struct LDKCOption_CVec_ThirtyTwoBytesZZ UnsignedBolt12Invoice_offer_chains(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42390 export function UnsignedBolt12Invoice_offer_chains(this_arg: bigint): bigint {
42391 if(!isWasmInitialized) {
42392 throw new Error("initializeWasm() must be awaited first!");
42394 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_offer_chains(this_arg);
42395 return nativeResponseValue;
42397 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedBolt12Invoice_chain(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42399 export function UnsignedBolt12Invoice_chain(this_arg: bigint): number {
42400 if(!isWasmInitialized) {
42401 throw new Error("initializeWasm() must be awaited first!");
42403 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_chain(this_arg);
42404 return nativeResponseValue;
42406 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ UnsignedBolt12Invoice_metadata(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42408 export function UnsignedBolt12Invoice_metadata(this_arg: bigint): bigint {
42409 if(!isWasmInitialized) {
42410 throw new Error("initializeWasm() must be awaited first!");
42412 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_metadata(this_arg);
42413 return nativeResponseValue;
42415 // MUST_USE_RES struct LDKAmount UnsignedBolt12Invoice_amount(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42417 export function UnsignedBolt12Invoice_amount(this_arg: bigint): bigint {
42418 if(!isWasmInitialized) {
42419 throw new Error("initializeWasm() must be awaited first!");
42421 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_amount(this_arg);
42422 return nativeResponseValue;
42424 // MUST_USE_RES struct LDKOfferFeatures UnsignedBolt12Invoice_offer_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42426 export function UnsignedBolt12Invoice_offer_features(this_arg: bigint): bigint {
42427 if(!isWasmInitialized) {
42428 throw new Error("initializeWasm() must be awaited first!");
42430 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_offer_features(this_arg);
42431 return nativeResponseValue;
42433 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_description(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42435 export function UnsignedBolt12Invoice_description(this_arg: bigint): bigint {
42436 if(!isWasmInitialized) {
42437 throw new Error("initializeWasm() must be awaited first!");
42439 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_description(this_arg);
42440 return nativeResponseValue;
42442 // MUST_USE_RES struct LDKCOption_u64Z UnsignedBolt12Invoice_absolute_expiry(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42444 export function UnsignedBolt12Invoice_absolute_expiry(this_arg: bigint): bigint {
42445 if(!isWasmInitialized) {
42446 throw new Error("initializeWasm() must be awaited first!");
42448 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_absolute_expiry(this_arg);
42449 return nativeResponseValue;
42451 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_issuer(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42453 export function UnsignedBolt12Invoice_issuer(this_arg: bigint): bigint {
42454 if(!isWasmInitialized) {
42455 throw new Error("initializeWasm() must be awaited first!");
42457 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_issuer(this_arg);
42458 return nativeResponseValue;
42460 // MUST_USE_RES struct LDKCVec_BlindedPathZ UnsignedBolt12Invoice_message_paths(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42462 export function UnsignedBolt12Invoice_message_paths(this_arg: bigint): number {
42463 if(!isWasmInitialized) {
42464 throw new Error("initializeWasm() must be awaited first!");
42466 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_message_paths(this_arg);
42467 return nativeResponseValue;
42469 // MUST_USE_RES struct LDKQuantity UnsignedBolt12Invoice_supported_quantity(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42471 export function UnsignedBolt12Invoice_supported_quantity(this_arg: bigint): bigint {
42472 if(!isWasmInitialized) {
42473 throw new Error("initializeWasm() must be awaited first!");
42475 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_supported_quantity(this_arg);
42476 return nativeResponseValue;
42478 // MUST_USE_RES struct LDKu8slice UnsignedBolt12Invoice_payer_metadata(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42480 export function UnsignedBolt12Invoice_payer_metadata(this_arg: bigint): number {
42481 if(!isWasmInitialized) {
42482 throw new Error("initializeWasm() must be awaited first!");
42484 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_metadata(this_arg);
42485 return nativeResponseValue;
42487 // MUST_USE_RES struct LDKInvoiceRequestFeatures UnsignedBolt12Invoice_invoice_request_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42489 export function UnsignedBolt12Invoice_invoice_request_features(this_arg: bigint): bigint {
42490 if(!isWasmInitialized) {
42491 throw new Error("initializeWasm() must be awaited first!");
42493 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_invoice_request_features(this_arg);
42494 return nativeResponseValue;
42496 // MUST_USE_RES struct LDKCOption_u64Z UnsignedBolt12Invoice_quantity(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42498 export function UnsignedBolt12Invoice_quantity(this_arg: bigint): bigint {
42499 if(!isWasmInitialized) {
42500 throw new Error("initializeWasm() must be awaited first!");
42502 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_quantity(this_arg);
42503 return nativeResponseValue;
42505 // MUST_USE_RES struct LDKPublicKey UnsignedBolt12Invoice_payer_id(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42507 export function UnsignedBolt12Invoice_payer_id(this_arg: bigint): number {
42508 if(!isWasmInitialized) {
42509 throw new Error("initializeWasm() must be awaited first!");
42511 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_id(this_arg);
42512 return nativeResponseValue;
42514 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_payer_note(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42516 export function UnsignedBolt12Invoice_payer_note(this_arg: bigint): bigint {
42517 if(!isWasmInitialized) {
42518 throw new Error("initializeWasm() must be awaited first!");
42520 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_note(this_arg);
42521 return nativeResponseValue;
42523 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_created_at(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42525 export function UnsignedBolt12Invoice_created_at(this_arg: bigint): bigint {
42526 if(!isWasmInitialized) {
42527 throw new Error("initializeWasm() must be awaited first!");
42529 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_created_at(this_arg);
42530 return nativeResponseValue;
42532 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_relative_expiry(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42534 export function UnsignedBolt12Invoice_relative_expiry(this_arg: bigint): bigint {
42535 if(!isWasmInitialized) {
42536 throw new Error("initializeWasm() must be awaited first!");
42538 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_relative_expiry(this_arg);
42539 return nativeResponseValue;
42541 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedBolt12Invoice_payment_hash(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42543 export function UnsignedBolt12Invoice_payment_hash(this_arg: bigint): number {
42544 if(!isWasmInitialized) {
42545 throw new Error("initializeWasm() must be awaited first!");
42547 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payment_hash(this_arg);
42548 return nativeResponseValue;
42550 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_amount_msats(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42552 export function UnsignedBolt12Invoice_amount_msats(this_arg: bigint): bigint {
42553 if(!isWasmInitialized) {
42554 throw new Error("initializeWasm() must be awaited first!");
42556 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_amount_msats(this_arg);
42557 return nativeResponseValue;
42559 // MUST_USE_RES struct LDKBolt12InvoiceFeatures UnsignedBolt12Invoice_invoice_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42561 export function UnsignedBolt12Invoice_invoice_features(this_arg: bigint): bigint {
42562 if(!isWasmInitialized) {
42563 throw new Error("initializeWasm() must be awaited first!");
42565 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_invoice_features(this_arg);
42566 return nativeResponseValue;
42568 // MUST_USE_RES struct LDKPublicKey UnsignedBolt12Invoice_signing_pubkey(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
42570 export function UnsignedBolt12Invoice_signing_pubkey(this_arg: bigint): number {
42571 if(!isWasmInitialized) {
42572 throw new Error("initializeWasm() must be awaited first!");
42574 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_signing_pubkey(this_arg);
42575 return nativeResponseValue;
42577 // MUST_USE_RES struct LDKCOption_CVec_ThirtyTwoBytesZZ Bolt12Invoice_offer_chains(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42579 export function Bolt12Invoice_offer_chains(this_arg: bigint): bigint {
42580 if(!isWasmInitialized) {
42581 throw new Error("initializeWasm() must be awaited first!");
42583 const nativeResponseValue = wasm.TS_Bolt12Invoice_offer_chains(this_arg);
42584 return nativeResponseValue;
42586 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_chain(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42588 export function Bolt12Invoice_chain(this_arg: bigint): number {
42589 if(!isWasmInitialized) {
42590 throw new Error("initializeWasm() must be awaited first!");
42592 const nativeResponseValue = wasm.TS_Bolt12Invoice_chain(this_arg);
42593 return nativeResponseValue;
42595 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Bolt12Invoice_metadata(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42597 export function Bolt12Invoice_metadata(this_arg: bigint): bigint {
42598 if(!isWasmInitialized) {
42599 throw new Error("initializeWasm() must be awaited first!");
42601 const nativeResponseValue = wasm.TS_Bolt12Invoice_metadata(this_arg);
42602 return nativeResponseValue;
42604 // MUST_USE_RES struct LDKAmount Bolt12Invoice_amount(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42606 export function Bolt12Invoice_amount(this_arg: bigint): bigint {
42607 if(!isWasmInitialized) {
42608 throw new Error("initializeWasm() must be awaited first!");
42610 const nativeResponseValue = wasm.TS_Bolt12Invoice_amount(this_arg);
42611 return nativeResponseValue;
42613 // MUST_USE_RES struct LDKOfferFeatures Bolt12Invoice_offer_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42615 export function Bolt12Invoice_offer_features(this_arg: bigint): bigint {
42616 if(!isWasmInitialized) {
42617 throw new Error("initializeWasm() must be awaited first!");
42619 const nativeResponseValue = wasm.TS_Bolt12Invoice_offer_features(this_arg);
42620 return nativeResponseValue;
42622 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_description(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42624 export function Bolt12Invoice_description(this_arg: bigint): bigint {
42625 if(!isWasmInitialized) {
42626 throw new Error("initializeWasm() must be awaited first!");
42628 const nativeResponseValue = wasm.TS_Bolt12Invoice_description(this_arg);
42629 return nativeResponseValue;
42631 // MUST_USE_RES struct LDKCOption_u64Z Bolt12Invoice_absolute_expiry(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42633 export function Bolt12Invoice_absolute_expiry(this_arg: bigint): bigint {
42634 if(!isWasmInitialized) {
42635 throw new Error("initializeWasm() must be awaited first!");
42637 const nativeResponseValue = wasm.TS_Bolt12Invoice_absolute_expiry(this_arg);
42638 return nativeResponseValue;
42640 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_issuer(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42642 export function Bolt12Invoice_issuer(this_arg: bigint): bigint {
42643 if(!isWasmInitialized) {
42644 throw new Error("initializeWasm() must be awaited first!");
42646 const nativeResponseValue = wasm.TS_Bolt12Invoice_issuer(this_arg);
42647 return nativeResponseValue;
42649 // MUST_USE_RES struct LDKCVec_BlindedPathZ Bolt12Invoice_message_paths(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42651 export function Bolt12Invoice_message_paths(this_arg: bigint): number {
42652 if(!isWasmInitialized) {
42653 throw new Error("initializeWasm() must be awaited first!");
42655 const nativeResponseValue = wasm.TS_Bolt12Invoice_message_paths(this_arg);
42656 return nativeResponseValue;
42658 // MUST_USE_RES struct LDKQuantity Bolt12Invoice_supported_quantity(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42660 export function Bolt12Invoice_supported_quantity(this_arg: bigint): bigint {
42661 if(!isWasmInitialized) {
42662 throw new Error("initializeWasm() must be awaited first!");
42664 const nativeResponseValue = wasm.TS_Bolt12Invoice_supported_quantity(this_arg);
42665 return nativeResponseValue;
42667 // MUST_USE_RES struct LDKu8slice Bolt12Invoice_payer_metadata(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42669 export function Bolt12Invoice_payer_metadata(this_arg: bigint): number {
42670 if(!isWasmInitialized) {
42671 throw new Error("initializeWasm() must be awaited first!");
42673 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_metadata(this_arg);
42674 return nativeResponseValue;
42676 // MUST_USE_RES struct LDKInvoiceRequestFeatures Bolt12Invoice_invoice_request_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42678 export function Bolt12Invoice_invoice_request_features(this_arg: bigint): bigint {
42679 if(!isWasmInitialized) {
42680 throw new Error("initializeWasm() must be awaited first!");
42682 const nativeResponseValue = wasm.TS_Bolt12Invoice_invoice_request_features(this_arg);
42683 return nativeResponseValue;
42685 // MUST_USE_RES struct LDKCOption_u64Z Bolt12Invoice_quantity(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42687 export function Bolt12Invoice_quantity(this_arg: bigint): bigint {
42688 if(!isWasmInitialized) {
42689 throw new Error("initializeWasm() must be awaited first!");
42691 const nativeResponseValue = wasm.TS_Bolt12Invoice_quantity(this_arg);
42692 return nativeResponseValue;
42694 // MUST_USE_RES struct LDKPublicKey Bolt12Invoice_payer_id(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42696 export function Bolt12Invoice_payer_id(this_arg: bigint): number {
42697 if(!isWasmInitialized) {
42698 throw new Error("initializeWasm() must be awaited first!");
42700 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_id(this_arg);
42701 return nativeResponseValue;
42703 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_payer_note(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42705 export function Bolt12Invoice_payer_note(this_arg: bigint): bigint {
42706 if(!isWasmInitialized) {
42707 throw new Error("initializeWasm() must be awaited first!");
42709 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_note(this_arg);
42710 return nativeResponseValue;
42712 // MUST_USE_RES uint64_t Bolt12Invoice_created_at(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42714 export function Bolt12Invoice_created_at(this_arg: bigint): bigint {
42715 if(!isWasmInitialized) {
42716 throw new Error("initializeWasm() must be awaited first!");
42718 const nativeResponseValue = wasm.TS_Bolt12Invoice_created_at(this_arg);
42719 return nativeResponseValue;
42721 // MUST_USE_RES uint64_t Bolt12Invoice_relative_expiry(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42723 export function Bolt12Invoice_relative_expiry(this_arg: bigint): bigint {
42724 if(!isWasmInitialized) {
42725 throw new Error("initializeWasm() must be awaited first!");
42727 const nativeResponseValue = wasm.TS_Bolt12Invoice_relative_expiry(this_arg);
42728 return nativeResponseValue;
42730 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_payment_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42732 export function Bolt12Invoice_payment_hash(this_arg: bigint): number {
42733 if(!isWasmInitialized) {
42734 throw new Error("initializeWasm() must be awaited first!");
42736 const nativeResponseValue = wasm.TS_Bolt12Invoice_payment_hash(this_arg);
42737 return nativeResponseValue;
42739 // MUST_USE_RES uint64_t Bolt12Invoice_amount_msats(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42741 export function Bolt12Invoice_amount_msats(this_arg: bigint): bigint {
42742 if(!isWasmInitialized) {
42743 throw new Error("initializeWasm() must be awaited first!");
42745 const nativeResponseValue = wasm.TS_Bolt12Invoice_amount_msats(this_arg);
42746 return nativeResponseValue;
42748 // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12Invoice_invoice_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42750 export function Bolt12Invoice_invoice_features(this_arg: bigint): bigint {
42751 if(!isWasmInitialized) {
42752 throw new Error("initializeWasm() must be awaited first!");
42754 const nativeResponseValue = wasm.TS_Bolt12Invoice_invoice_features(this_arg);
42755 return nativeResponseValue;
42757 // MUST_USE_RES struct LDKPublicKey Bolt12Invoice_signing_pubkey(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42759 export function Bolt12Invoice_signing_pubkey(this_arg: bigint): number {
42760 if(!isWasmInitialized) {
42761 throw new Error("initializeWasm() must be awaited first!");
42763 const nativeResponseValue = wasm.TS_Bolt12Invoice_signing_pubkey(this_arg);
42764 return nativeResponseValue;
42766 // MUST_USE_RES struct LDKSchnorrSignature Bolt12Invoice_signature(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42768 export function Bolt12Invoice_signature(this_arg: bigint): number {
42769 if(!isWasmInitialized) {
42770 throw new Error("initializeWasm() must be awaited first!");
42772 const nativeResponseValue = wasm.TS_Bolt12Invoice_signature(this_arg);
42773 return nativeResponseValue;
42775 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_signable_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
42777 export function Bolt12Invoice_signable_hash(this_arg: bigint): number {
42778 if(!isWasmInitialized) {
42779 throw new Error("initializeWasm() must be awaited first!");
42781 const nativeResponseValue = wasm.TS_Bolt12Invoice_signable_hash(this_arg);
42782 return nativeResponseValue;
42784 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesNoneZ Bolt12Invoice_verify(const struct LDKBolt12Invoice *NONNULL_PTR this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
42786 export function Bolt12Invoice_verify(this_arg: bigint, key: bigint): bigint {
42787 if(!isWasmInitialized) {
42788 throw new Error("initializeWasm() must be awaited first!");
42790 const nativeResponseValue = wasm.TS_Bolt12Invoice_verify(this_arg, key);
42791 return nativeResponseValue;
42793 // struct LDKCVec_u8Z UnsignedBolt12Invoice_write(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR obj);
42795 export function UnsignedBolt12Invoice_write(obj: bigint): number {
42796 if(!isWasmInitialized) {
42797 throw new Error("initializeWasm() must be awaited first!");
42799 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_write(obj);
42800 return nativeResponseValue;
42802 // struct LDKCVec_u8Z Bolt12Invoice_write(const struct LDKBolt12Invoice *NONNULL_PTR obj);
42804 export function Bolt12Invoice_write(obj: bigint): number {
42805 if(!isWasmInitialized) {
42806 throw new Error("initializeWasm() must be awaited first!");
42808 const nativeResponseValue = wasm.TS_Bolt12Invoice_write(obj);
42809 return nativeResponseValue;
42811 // void BlindedPayInfo_free(struct LDKBlindedPayInfo this_obj);
42813 export function BlindedPayInfo_free(this_obj: bigint): void {
42814 if(!isWasmInitialized) {
42815 throw new Error("initializeWasm() must be awaited first!");
42817 const nativeResponseValue = wasm.TS_BlindedPayInfo_free(this_obj);
42818 // debug statements here
42820 // uint32_t BlindedPayInfo_get_fee_base_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42822 export function BlindedPayInfo_get_fee_base_msat(this_ptr: bigint): number {
42823 if(!isWasmInitialized) {
42824 throw new Error("initializeWasm() must be awaited first!");
42826 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_base_msat(this_ptr);
42827 return nativeResponseValue;
42829 // void BlindedPayInfo_set_fee_base_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
42831 export function BlindedPayInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
42832 if(!isWasmInitialized) {
42833 throw new Error("initializeWasm() must be awaited first!");
42835 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_base_msat(this_ptr, val);
42836 // debug statements here
42838 // uint32_t BlindedPayInfo_get_fee_proportional_millionths(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42840 export function BlindedPayInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
42841 if(!isWasmInitialized) {
42842 throw new Error("initializeWasm() must be awaited first!");
42844 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_proportional_millionths(this_ptr);
42845 return nativeResponseValue;
42847 // void BlindedPayInfo_set_fee_proportional_millionths(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
42849 export function BlindedPayInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
42850 if(!isWasmInitialized) {
42851 throw new Error("initializeWasm() must be awaited first!");
42853 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_proportional_millionths(this_ptr, val);
42854 // debug statements here
42856 // uint16_t BlindedPayInfo_get_cltv_expiry_delta(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42858 export function BlindedPayInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
42859 if(!isWasmInitialized) {
42860 throw new Error("initializeWasm() must be awaited first!");
42862 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_cltv_expiry_delta(this_ptr);
42863 return nativeResponseValue;
42865 // void BlindedPayInfo_set_cltv_expiry_delta(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint16_t val);
42867 export function BlindedPayInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
42868 if(!isWasmInitialized) {
42869 throw new Error("initializeWasm() must be awaited first!");
42871 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_cltv_expiry_delta(this_ptr, val);
42872 // debug statements here
42874 // uint64_t BlindedPayInfo_get_htlc_minimum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42876 export function BlindedPayInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
42877 if(!isWasmInitialized) {
42878 throw new Error("initializeWasm() must be awaited first!");
42880 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_minimum_msat(this_ptr);
42881 return nativeResponseValue;
42883 // void BlindedPayInfo_set_htlc_minimum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
42885 export function BlindedPayInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
42886 if(!isWasmInitialized) {
42887 throw new Error("initializeWasm() must be awaited first!");
42889 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_minimum_msat(this_ptr, val);
42890 // debug statements here
42892 // uint64_t BlindedPayInfo_get_htlc_maximum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42894 export function BlindedPayInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
42895 if(!isWasmInitialized) {
42896 throw new Error("initializeWasm() must be awaited first!");
42898 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_maximum_msat(this_ptr);
42899 return nativeResponseValue;
42901 // void BlindedPayInfo_set_htlc_maximum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
42903 export function BlindedPayInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
42904 if(!isWasmInitialized) {
42905 throw new Error("initializeWasm() must be awaited first!");
42907 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_maximum_msat(this_ptr, val);
42908 // debug statements here
42910 // struct LDKBlindedHopFeatures BlindedPayInfo_get_features(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
42912 export function BlindedPayInfo_get_features(this_ptr: bigint): bigint {
42913 if(!isWasmInitialized) {
42914 throw new Error("initializeWasm() must be awaited first!");
42916 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_features(this_ptr);
42917 return nativeResponseValue;
42919 // void BlindedPayInfo_set_features(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, struct LDKBlindedHopFeatures val);
42921 export function BlindedPayInfo_set_features(this_ptr: bigint, val: bigint): void {
42922 if(!isWasmInitialized) {
42923 throw new Error("initializeWasm() must be awaited first!");
42925 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_features(this_ptr, val);
42926 // debug statements here
42928 // 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);
42930 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 {
42931 if(!isWasmInitialized) {
42932 throw new Error("initializeWasm() must be awaited first!");
42934 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);
42935 return nativeResponseValue;
42937 // uint64_t BlindedPayInfo_clone_ptr(LDKBlindedPayInfo *NONNULL_PTR arg);
42939 export function BlindedPayInfo_clone_ptr(arg: bigint): bigint {
42940 if(!isWasmInitialized) {
42941 throw new Error("initializeWasm() must be awaited first!");
42943 const nativeResponseValue = wasm.TS_BlindedPayInfo_clone_ptr(arg);
42944 return nativeResponseValue;
42946 // struct LDKBlindedPayInfo BlindedPayInfo_clone(const struct LDKBlindedPayInfo *NONNULL_PTR orig);
42948 export function BlindedPayInfo_clone(orig: bigint): bigint {
42949 if(!isWasmInitialized) {
42950 throw new Error("initializeWasm() must be awaited first!");
42952 const nativeResponseValue = wasm.TS_BlindedPayInfo_clone(orig);
42953 return nativeResponseValue;
42955 // uint64_t BlindedPayInfo_hash(const struct LDKBlindedPayInfo *NONNULL_PTR o);
42957 export function BlindedPayInfo_hash(o: bigint): bigint {
42958 if(!isWasmInitialized) {
42959 throw new Error("initializeWasm() must be awaited first!");
42961 const nativeResponseValue = wasm.TS_BlindedPayInfo_hash(o);
42962 return nativeResponseValue;
42964 // bool BlindedPayInfo_eq(const struct LDKBlindedPayInfo *NONNULL_PTR a, const struct LDKBlindedPayInfo *NONNULL_PTR b);
42966 export function BlindedPayInfo_eq(a: bigint, b: bigint): boolean {
42967 if(!isWasmInitialized) {
42968 throw new Error("initializeWasm() must be awaited first!");
42970 const nativeResponseValue = wasm.TS_BlindedPayInfo_eq(a, b);
42971 return nativeResponseValue;
42973 // struct LDKCVec_u8Z BlindedPayInfo_write(const struct LDKBlindedPayInfo *NONNULL_PTR obj);
42975 export function BlindedPayInfo_write(obj: bigint): number {
42976 if(!isWasmInitialized) {
42977 throw new Error("initializeWasm() must be awaited first!");
42979 const nativeResponseValue = wasm.TS_BlindedPayInfo_write(obj);
42980 return nativeResponseValue;
42982 // struct LDKCResult_BlindedPayInfoDecodeErrorZ BlindedPayInfo_read(struct LDKu8slice ser);
42984 export function BlindedPayInfo_read(ser: number): bigint {
42985 if(!isWasmInitialized) {
42986 throw new Error("initializeWasm() must be awaited first!");
42988 const nativeResponseValue = wasm.TS_BlindedPayInfo_read(ser);
42989 return nativeResponseValue;
42991 // void InvoiceError_free(struct LDKInvoiceError this_obj);
42993 export function InvoiceError_free(this_obj: bigint): void {
42994 if(!isWasmInitialized) {
42995 throw new Error("initializeWasm() must be awaited first!");
42997 const nativeResponseValue = wasm.TS_InvoiceError_free(this_obj);
42998 // debug statements here
43000 // struct LDKErroneousField InvoiceError_get_erroneous_field(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
43002 export function InvoiceError_get_erroneous_field(this_ptr: bigint): bigint {
43003 if(!isWasmInitialized) {
43004 throw new Error("initializeWasm() must be awaited first!");
43006 const nativeResponseValue = wasm.TS_InvoiceError_get_erroneous_field(this_ptr);
43007 return nativeResponseValue;
43009 // void InvoiceError_set_erroneous_field(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKErroneousField val);
43011 export function InvoiceError_set_erroneous_field(this_ptr: bigint, val: bigint): void {
43012 if(!isWasmInitialized) {
43013 throw new Error("initializeWasm() must be awaited first!");
43015 const nativeResponseValue = wasm.TS_InvoiceError_set_erroneous_field(this_ptr, val);
43016 // debug statements here
43018 // struct LDKUntrustedString InvoiceError_get_message(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
43020 export function InvoiceError_get_message(this_ptr: bigint): bigint {
43021 if(!isWasmInitialized) {
43022 throw new Error("initializeWasm() must be awaited first!");
43024 const nativeResponseValue = wasm.TS_InvoiceError_get_message(this_ptr);
43025 return nativeResponseValue;
43027 // void InvoiceError_set_message(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKUntrustedString val);
43029 export function InvoiceError_set_message(this_ptr: bigint, val: bigint): void {
43030 if(!isWasmInitialized) {
43031 throw new Error("initializeWasm() must be awaited first!");
43033 const nativeResponseValue = wasm.TS_InvoiceError_set_message(this_ptr, val);
43034 // debug statements here
43036 // MUST_USE_RES struct LDKInvoiceError InvoiceError_new(struct LDKErroneousField erroneous_field_arg, struct LDKUntrustedString message_arg);
43038 export function InvoiceError_new(erroneous_field_arg: bigint, message_arg: bigint): bigint {
43039 if(!isWasmInitialized) {
43040 throw new Error("initializeWasm() must be awaited first!");
43042 const nativeResponseValue = wasm.TS_InvoiceError_new(erroneous_field_arg, message_arg);
43043 return nativeResponseValue;
43045 // uint64_t InvoiceError_clone_ptr(LDKInvoiceError *NONNULL_PTR arg);
43047 export function InvoiceError_clone_ptr(arg: bigint): bigint {
43048 if(!isWasmInitialized) {
43049 throw new Error("initializeWasm() must be awaited first!");
43051 const nativeResponseValue = wasm.TS_InvoiceError_clone_ptr(arg);
43052 return nativeResponseValue;
43054 // struct LDKInvoiceError InvoiceError_clone(const struct LDKInvoiceError *NONNULL_PTR orig);
43056 export function InvoiceError_clone(orig: bigint): bigint {
43057 if(!isWasmInitialized) {
43058 throw new Error("initializeWasm() must be awaited first!");
43060 const nativeResponseValue = wasm.TS_InvoiceError_clone(orig);
43061 return nativeResponseValue;
43063 // void ErroneousField_free(struct LDKErroneousField this_obj);
43065 export function ErroneousField_free(this_obj: bigint): void {
43066 if(!isWasmInitialized) {
43067 throw new Error("initializeWasm() must be awaited first!");
43069 const nativeResponseValue = wasm.TS_ErroneousField_free(this_obj);
43070 // debug statements here
43072 // uint64_t ErroneousField_get_tlv_fieldnum(const struct LDKErroneousField *NONNULL_PTR this_ptr);
43074 export function ErroneousField_get_tlv_fieldnum(this_ptr: bigint): bigint {
43075 if(!isWasmInitialized) {
43076 throw new Error("initializeWasm() must be awaited first!");
43078 const nativeResponseValue = wasm.TS_ErroneousField_get_tlv_fieldnum(this_ptr);
43079 return nativeResponseValue;
43081 // void ErroneousField_set_tlv_fieldnum(struct LDKErroneousField *NONNULL_PTR this_ptr, uint64_t val);
43083 export function ErroneousField_set_tlv_fieldnum(this_ptr: bigint, val: bigint): void {
43084 if(!isWasmInitialized) {
43085 throw new Error("initializeWasm() must be awaited first!");
43087 const nativeResponseValue = wasm.TS_ErroneousField_set_tlv_fieldnum(this_ptr, val);
43088 // debug statements here
43090 // struct LDKCOption_CVec_u8ZZ ErroneousField_get_suggested_value(const struct LDKErroneousField *NONNULL_PTR this_ptr);
43092 export function ErroneousField_get_suggested_value(this_ptr: bigint): bigint {
43093 if(!isWasmInitialized) {
43094 throw new Error("initializeWasm() must be awaited first!");
43096 const nativeResponseValue = wasm.TS_ErroneousField_get_suggested_value(this_ptr);
43097 return nativeResponseValue;
43099 // void ErroneousField_set_suggested_value(struct LDKErroneousField *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
43101 export function ErroneousField_set_suggested_value(this_ptr: bigint, val: bigint): void {
43102 if(!isWasmInitialized) {
43103 throw new Error("initializeWasm() must be awaited first!");
43105 const nativeResponseValue = wasm.TS_ErroneousField_set_suggested_value(this_ptr, val);
43106 // debug statements here
43108 // MUST_USE_RES struct LDKErroneousField ErroneousField_new(uint64_t tlv_fieldnum_arg, struct LDKCOption_CVec_u8ZZ suggested_value_arg);
43110 export function ErroneousField_new(tlv_fieldnum_arg: bigint, suggested_value_arg: bigint): bigint {
43111 if(!isWasmInitialized) {
43112 throw new Error("initializeWasm() must be awaited first!");
43114 const nativeResponseValue = wasm.TS_ErroneousField_new(tlv_fieldnum_arg, suggested_value_arg);
43115 return nativeResponseValue;
43117 // uint64_t ErroneousField_clone_ptr(LDKErroneousField *NONNULL_PTR arg);
43119 export function ErroneousField_clone_ptr(arg: bigint): bigint {
43120 if(!isWasmInitialized) {
43121 throw new Error("initializeWasm() must be awaited first!");
43123 const nativeResponseValue = wasm.TS_ErroneousField_clone_ptr(arg);
43124 return nativeResponseValue;
43126 // struct LDKErroneousField ErroneousField_clone(const struct LDKErroneousField *NONNULL_PTR orig);
43128 export function ErroneousField_clone(orig: bigint): bigint {
43129 if(!isWasmInitialized) {
43130 throw new Error("initializeWasm() must be awaited first!");
43132 const nativeResponseValue = wasm.TS_ErroneousField_clone(orig);
43133 return nativeResponseValue;
43135 // MUST_USE_RES struct LDKInvoiceError InvoiceError_from_string(struct LDKStr s);
43137 export function InvoiceError_from_string(s: number): bigint {
43138 if(!isWasmInitialized) {
43139 throw new Error("initializeWasm() must be awaited first!");
43141 const nativeResponseValue = wasm.TS_InvoiceError_from_string(s);
43142 return nativeResponseValue;
43144 // struct LDKCVec_u8Z InvoiceError_write(const struct LDKInvoiceError *NONNULL_PTR obj);
43146 export function InvoiceError_write(obj: bigint): number {
43147 if(!isWasmInitialized) {
43148 throw new Error("initializeWasm() must be awaited first!");
43150 const nativeResponseValue = wasm.TS_InvoiceError_write(obj);
43151 return nativeResponseValue;
43153 // struct LDKCResult_InvoiceErrorDecodeErrorZ InvoiceError_read(struct LDKu8slice ser);
43155 export function InvoiceError_read(ser: number): bigint {
43156 if(!isWasmInitialized) {
43157 throw new Error("initializeWasm() must be awaited first!");
43159 const nativeResponseValue = wasm.TS_InvoiceError_read(ser);
43160 return nativeResponseValue;
43162 // void UnsignedInvoiceRequest_free(struct LDKUnsignedInvoiceRequest this_obj);
43164 export function UnsignedInvoiceRequest_free(this_obj: bigint): void {
43165 if(!isWasmInitialized) {
43166 throw new Error("initializeWasm() must be awaited first!");
43168 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_free(this_obj);
43169 // debug statements here
43171 // MUST_USE_RES struct LDKTaggedHash UnsignedInvoiceRequest_tagged_hash(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43173 export function UnsignedInvoiceRequest_tagged_hash(this_arg: bigint): bigint {
43174 if(!isWasmInitialized) {
43175 throw new Error("initializeWasm() must be awaited first!");
43177 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_tagged_hash(this_arg);
43178 return nativeResponseValue;
43180 // void InvoiceRequest_free(struct LDKInvoiceRequest this_obj);
43182 export function InvoiceRequest_free(this_obj: bigint): void {
43183 if(!isWasmInitialized) {
43184 throw new Error("initializeWasm() must be awaited first!");
43186 const nativeResponseValue = wasm.TS_InvoiceRequest_free(this_obj);
43187 // debug statements here
43189 // uint64_t InvoiceRequest_clone_ptr(LDKInvoiceRequest *NONNULL_PTR arg);
43191 export function InvoiceRequest_clone_ptr(arg: bigint): bigint {
43192 if(!isWasmInitialized) {
43193 throw new Error("initializeWasm() must be awaited first!");
43195 const nativeResponseValue = wasm.TS_InvoiceRequest_clone_ptr(arg);
43196 return nativeResponseValue;
43198 // struct LDKInvoiceRequest InvoiceRequest_clone(const struct LDKInvoiceRequest *NONNULL_PTR orig);
43200 export function InvoiceRequest_clone(orig: bigint): bigint {
43201 if(!isWasmInitialized) {
43202 throw new Error("initializeWasm() must be awaited first!");
43204 const nativeResponseValue = wasm.TS_InvoiceRequest_clone(orig);
43205 return nativeResponseValue;
43207 // void VerifiedInvoiceRequest_free(struct LDKVerifiedInvoiceRequest this_obj);
43209 export function VerifiedInvoiceRequest_free(this_obj: bigint): void {
43210 if(!isWasmInitialized) {
43211 throw new Error("initializeWasm() must be awaited first!");
43213 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_free(this_obj);
43214 // debug statements here
43216 // struct LDKCOption_SecretKeyZ VerifiedInvoiceRequest_get_keys(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr);
43218 export function VerifiedInvoiceRequest_get_keys(this_ptr: bigint): bigint {
43219 if(!isWasmInitialized) {
43220 throw new Error("initializeWasm() must be awaited first!");
43222 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_get_keys(this_ptr);
43223 return nativeResponseValue;
43225 // void VerifiedInvoiceRequest_set_keys(struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr, struct LDKCOption_SecretKeyZ val);
43227 export function VerifiedInvoiceRequest_set_keys(this_ptr: bigint, val: bigint): void {
43228 if(!isWasmInitialized) {
43229 throw new Error("initializeWasm() must be awaited first!");
43231 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_set_keys(this_ptr, val);
43232 // debug statements here
43234 // uint64_t VerifiedInvoiceRequest_clone_ptr(LDKVerifiedInvoiceRequest *NONNULL_PTR arg);
43236 export function VerifiedInvoiceRequest_clone_ptr(arg: bigint): bigint {
43237 if(!isWasmInitialized) {
43238 throw new Error("initializeWasm() must be awaited first!");
43240 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_clone_ptr(arg);
43241 return nativeResponseValue;
43243 // struct LDKVerifiedInvoiceRequest VerifiedInvoiceRequest_clone(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR orig);
43245 export function VerifiedInvoiceRequest_clone(orig: bigint): bigint {
43246 if(!isWasmInitialized) {
43247 throw new Error("initializeWasm() must be awaited first!");
43249 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_clone(orig);
43250 return nativeResponseValue;
43252 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ UnsignedInvoiceRequest_chains(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43254 export function UnsignedInvoiceRequest_chains(this_arg: bigint): number {
43255 if(!isWasmInitialized) {
43256 throw new Error("initializeWasm() must be awaited first!");
43258 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_chains(this_arg);
43259 return nativeResponseValue;
43261 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ UnsignedInvoiceRequest_metadata(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43263 export function UnsignedInvoiceRequest_metadata(this_arg: bigint): bigint {
43264 if(!isWasmInitialized) {
43265 throw new Error("initializeWasm() must be awaited first!");
43267 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_metadata(this_arg);
43268 return nativeResponseValue;
43270 // MUST_USE_RES struct LDKAmount UnsignedInvoiceRequest_amount(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43272 export function UnsignedInvoiceRequest_amount(this_arg: bigint): bigint {
43273 if(!isWasmInitialized) {
43274 throw new Error("initializeWasm() must be awaited first!");
43276 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_amount(this_arg);
43277 return nativeResponseValue;
43279 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_description(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43281 export function UnsignedInvoiceRequest_description(this_arg: bigint): bigint {
43282 if(!isWasmInitialized) {
43283 throw new Error("initializeWasm() must be awaited first!");
43285 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_description(this_arg);
43286 return nativeResponseValue;
43288 // MUST_USE_RES struct LDKOfferFeatures UnsignedInvoiceRequest_offer_features(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43290 export function UnsignedInvoiceRequest_offer_features(this_arg: bigint): bigint {
43291 if(!isWasmInitialized) {
43292 throw new Error("initializeWasm() must be awaited first!");
43294 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_offer_features(this_arg);
43295 return nativeResponseValue;
43297 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_absolute_expiry(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43299 export function UnsignedInvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
43300 if(!isWasmInitialized) {
43301 throw new Error("initializeWasm() must be awaited first!");
43303 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_absolute_expiry(this_arg);
43304 return nativeResponseValue;
43306 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_issuer(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43308 export function UnsignedInvoiceRequest_issuer(this_arg: bigint): bigint {
43309 if(!isWasmInitialized) {
43310 throw new Error("initializeWasm() must be awaited first!");
43312 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_issuer(this_arg);
43313 return nativeResponseValue;
43315 // MUST_USE_RES struct LDKCVec_BlindedPathZ UnsignedInvoiceRequest_paths(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43317 export function UnsignedInvoiceRequest_paths(this_arg: bigint): number {
43318 if(!isWasmInitialized) {
43319 throw new Error("initializeWasm() must be awaited first!");
43321 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_paths(this_arg);
43322 return nativeResponseValue;
43324 // MUST_USE_RES struct LDKQuantity UnsignedInvoiceRequest_supported_quantity(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43326 export function UnsignedInvoiceRequest_supported_quantity(this_arg: bigint): bigint {
43327 if(!isWasmInitialized) {
43328 throw new Error("initializeWasm() must be awaited first!");
43330 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_supported_quantity(this_arg);
43331 return nativeResponseValue;
43333 // MUST_USE_RES struct LDKPublicKey UnsignedInvoiceRequest_signing_pubkey(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43335 export function UnsignedInvoiceRequest_signing_pubkey(this_arg: bigint): number {
43336 if(!isWasmInitialized) {
43337 throw new Error("initializeWasm() must be awaited first!");
43339 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_signing_pubkey(this_arg);
43340 return nativeResponseValue;
43342 // MUST_USE_RES struct LDKu8slice UnsignedInvoiceRequest_payer_metadata(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43344 export function UnsignedInvoiceRequest_payer_metadata(this_arg: bigint): number {
43345 if(!isWasmInitialized) {
43346 throw new Error("initializeWasm() must be awaited first!");
43348 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_metadata(this_arg);
43349 return nativeResponseValue;
43351 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedInvoiceRequest_chain(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43353 export function UnsignedInvoiceRequest_chain(this_arg: bigint): number {
43354 if(!isWasmInitialized) {
43355 throw new Error("initializeWasm() must be awaited first!");
43357 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_chain(this_arg);
43358 return nativeResponseValue;
43360 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_amount_msats(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43362 export function UnsignedInvoiceRequest_amount_msats(this_arg: bigint): bigint {
43363 if(!isWasmInitialized) {
43364 throw new Error("initializeWasm() must be awaited first!");
43366 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_amount_msats(this_arg);
43367 return nativeResponseValue;
43369 // MUST_USE_RES struct LDKInvoiceRequestFeatures UnsignedInvoiceRequest_invoice_request_features(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43371 export function UnsignedInvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
43372 if(!isWasmInitialized) {
43373 throw new Error("initializeWasm() must be awaited first!");
43375 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_invoice_request_features(this_arg);
43376 return nativeResponseValue;
43378 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_quantity(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43380 export function UnsignedInvoiceRequest_quantity(this_arg: bigint): bigint {
43381 if(!isWasmInitialized) {
43382 throw new Error("initializeWasm() must be awaited first!");
43384 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_quantity(this_arg);
43385 return nativeResponseValue;
43387 // MUST_USE_RES struct LDKPublicKey UnsignedInvoiceRequest_payer_id(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43389 export function UnsignedInvoiceRequest_payer_id(this_arg: bigint): number {
43390 if(!isWasmInitialized) {
43391 throw new Error("initializeWasm() must be awaited first!");
43393 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_id(this_arg);
43394 return nativeResponseValue;
43396 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_payer_note(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
43398 export function UnsignedInvoiceRequest_payer_note(this_arg: bigint): bigint {
43399 if(!isWasmInitialized) {
43400 throw new Error("initializeWasm() must be awaited first!");
43402 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_note(this_arg);
43403 return nativeResponseValue;
43405 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ InvoiceRequest_chains(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43407 export function InvoiceRequest_chains(this_arg: bigint): number {
43408 if(!isWasmInitialized) {
43409 throw new Error("initializeWasm() must be awaited first!");
43411 const nativeResponseValue = wasm.TS_InvoiceRequest_chains(this_arg);
43412 return nativeResponseValue;
43414 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ InvoiceRequest_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43416 export function InvoiceRequest_metadata(this_arg: bigint): bigint {
43417 if(!isWasmInitialized) {
43418 throw new Error("initializeWasm() must be awaited first!");
43420 const nativeResponseValue = wasm.TS_InvoiceRequest_metadata(this_arg);
43421 return nativeResponseValue;
43423 // MUST_USE_RES struct LDKAmount InvoiceRequest_amount(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43425 export function InvoiceRequest_amount(this_arg: bigint): bigint {
43426 if(!isWasmInitialized) {
43427 throw new Error("initializeWasm() must be awaited first!");
43429 const nativeResponseValue = wasm.TS_InvoiceRequest_amount(this_arg);
43430 return nativeResponseValue;
43432 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_description(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43434 export function InvoiceRequest_description(this_arg: bigint): bigint {
43435 if(!isWasmInitialized) {
43436 throw new Error("initializeWasm() must be awaited first!");
43438 const nativeResponseValue = wasm.TS_InvoiceRequest_description(this_arg);
43439 return nativeResponseValue;
43441 // MUST_USE_RES struct LDKOfferFeatures InvoiceRequest_offer_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43443 export function InvoiceRequest_offer_features(this_arg: bigint): bigint {
43444 if(!isWasmInitialized) {
43445 throw new Error("initializeWasm() must be awaited first!");
43447 const nativeResponseValue = wasm.TS_InvoiceRequest_offer_features(this_arg);
43448 return nativeResponseValue;
43450 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_absolute_expiry(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43452 export function InvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
43453 if(!isWasmInitialized) {
43454 throw new Error("initializeWasm() must be awaited first!");
43456 const nativeResponseValue = wasm.TS_InvoiceRequest_absolute_expiry(this_arg);
43457 return nativeResponseValue;
43459 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_issuer(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43461 export function InvoiceRequest_issuer(this_arg: bigint): bigint {
43462 if(!isWasmInitialized) {
43463 throw new Error("initializeWasm() must be awaited first!");
43465 const nativeResponseValue = wasm.TS_InvoiceRequest_issuer(this_arg);
43466 return nativeResponseValue;
43468 // MUST_USE_RES struct LDKCVec_BlindedPathZ InvoiceRequest_paths(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43470 export function InvoiceRequest_paths(this_arg: bigint): number {
43471 if(!isWasmInitialized) {
43472 throw new Error("initializeWasm() must be awaited first!");
43474 const nativeResponseValue = wasm.TS_InvoiceRequest_paths(this_arg);
43475 return nativeResponseValue;
43477 // MUST_USE_RES struct LDKQuantity InvoiceRequest_supported_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43479 export function InvoiceRequest_supported_quantity(this_arg: bigint): bigint {
43480 if(!isWasmInitialized) {
43481 throw new Error("initializeWasm() must be awaited first!");
43483 const nativeResponseValue = wasm.TS_InvoiceRequest_supported_quantity(this_arg);
43484 return nativeResponseValue;
43486 // MUST_USE_RES struct LDKPublicKey InvoiceRequest_signing_pubkey(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43488 export function InvoiceRequest_signing_pubkey(this_arg: bigint): number {
43489 if(!isWasmInitialized) {
43490 throw new Error("initializeWasm() must be awaited first!");
43492 const nativeResponseValue = wasm.TS_InvoiceRequest_signing_pubkey(this_arg);
43493 return nativeResponseValue;
43495 // MUST_USE_RES struct LDKu8slice InvoiceRequest_payer_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43497 export function InvoiceRequest_payer_metadata(this_arg: bigint): number {
43498 if(!isWasmInitialized) {
43499 throw new Error("initializeWasm() must be awaited first!");
43501 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_metadata(this_arg);
43502 return nativeResponseValue;
43504 // MUST_USE_RES struct LDKThirtyTwoBytes InvoiceRequest_chain(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43506 export function InvoiceRequest_chain(this_arg: bigint): number {
43507 if(!isWasmInitialized) {
43508 throw new Error("initializeWasm() must be awaited first!");
43510 const nativeResponseValue = wasm.TS_InvoiceRequest_chain(this_arg);
43511 return nativeResponseValue;
43513 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_amount_msats(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43515 export function InvoiceRequest_amount_msats(this_arg: bigint): bigint {
43516 if(!isWasmInitialized) {
43517 throw new Error("initializeWasm() must be awaited first!");
43519 const nativeResponseValue = wasm.TS_InvoiceRequest_amount_msats(this_arg);
43520 return nativeResponseValue;
43522 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequest_invoice_request_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43524 export function InvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
43525 if(!isWasmInitialized) {
43526 throw new Error("initializeWasm() must be awaited first!");
43528 const nativeResponseValue = wasm.TS_InvoiceRequest_invoice_request_features(this_arg);
43529 return nativeResponseValue;
43531 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43533 export function InvoiceRequest_quantity(this_arg: bigint): bigint {
43534 if(!isWasmInitialized) {
43535 throw new Error("initializeWasm() must be awaited first!");
43537 const nativeResponseValue = wasm.TS_InvoiceRequest_quantity(this_arg);
43538 return nativeResponseValue;
43540 // MUST_USE_RES struct LDKPublicKey InvoiceRequest_payer_id(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43542 export function InvoiceRequest_payer_id(this_arg: bigint): number {
43543 if(!isWasmInitialized) {
43544 throw new Error("initializeWasm() must be awaited first!");
43546 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_id(this_arg);
43547 return nativeResponseValue;
43549 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_payer_note(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43551 export function InvoiceRequest_payer_note(this_arg: bigint): bigint {
43552 if(!isWasmInitialized) {
43553 throw new Error("initializeWasm() must be awaited first!");
43555 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_note(this_arg);
43556 return nativeResponseValue;
43558 // MUST_USE_RES struct LDKSchnorrSignature InvoiceRequest_signature(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
43560 export function InvoiceRequest_signature(this_arg: bigint): number {
43561 if(!isWasmInitialized) {
43562 throw new Error("initializeWasm() must be awaited first!");
43564 const nativeResponseValue = wasm.TS_InvoiceRequest_signature(this_arg);
43565 return nativeResponseValue;
43567 // MUST_USE_RES struct LDKCResult_VerifiedInvoiceRequestNoneZ InvoiceRequest_verify(struct LDKInvoiceRequest this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
43569 export function InvoiceRequest_verify(this_arg: bigint, key: bigint): bigint {
43570 if(!isWasmInitialized) {
43571 throw new Error("initializeWasm() must be awaited first!");
43573 const nativeResponseValue = wasm.TS_InvoiceRequest_verify(this_arg, key);
43574 return nativeResponseValue;
43576 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ VerifiedInvoiceRequest_chains(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43578 export function VerifiedInvoiceRequest_chains(this_arg: bigint): number {
43579 if(!isWasmInitialized) {
43580 throw new Error("initializeWasm() must be awaited first!");
43582 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_chains(this_arg);
43583 return nativeResponseValue;
43585 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ VerifiedInvoiceRequest_metadata(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43587 export function VerifiedInvoiceRequest_metadata(this_arg: bigint): bigint {
43588 if(!isWasmInitialized) {
43589 throw new Error("initializeWasm() must be awaited first!");
43591 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_metadata(this_arg);
43592 return nativeResponseValue;
43594 // MUST_USE_RES struct LDKAmount VerifiedInvoiceRequest_amount(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43596 export function VerifiedInvoiceRequest_amount(this_arg: bigint): bigint {
43597 if(!isWasmInitialized) {
43598 throw new Error("initializeWasm() must be awaited first!");
43600 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_amount(this_arg);
43601 return nativeResponseValue;
43603 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_description(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43605 export function VerifiedInvoiceRequest_description(this_arg: bigint): bigint {
43606 if(!isWasmInitialized) {
43607 throw new Error("initializeWasm() must be awaited first!");
43609 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_description(this_arg);
43610 return nativeResponseValue;
43612 // MUST_USE_RES struct LDKOfferFeatures VerifiedInvoiceRequest_offer_features(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43614 export function VerifiedInvoiceRequest_offer_features(this_arg: bigint): bigint {
43615 if(!isWasmInitialized) {
43616 throw new Error("initializeWasm() must be awaited first!");
43618 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_offer_features(this_arg);
43619 return nativeResponseValue;
43621 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_absolute_expiry(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43623 export function VerifiedInvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
43624 if(!isWasmInitialized) {
43625 throw new Error("initializeWasm() must be awaited first!");
43627 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_absolute_expiry(this_arg);
43628 return nativeResponseValue;
43630 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_issuer(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43632 export function VerifiedInvoiceRequest_issuer(this_arg: bigint): bigint {
43633 if(!isWasmInitialized) {
43634 throw new Error("initializeWasm() must be awaited first!");
43636 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_issuer(this_arg);
43637 return nativeResponseValue;
43639 // MUST_USE_RES struct LDKCVec_BlindedPathZ VerifiedInvoiceRequest_paths(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43641 export function VerifiedInvoiceRequest_paths(this_arg: bigint): number {
43642 if(!isWasmInitialized) {
43643 throw new Error("initializeWasm() must be awaited first!");
43645 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_paths(this_arg);
43646 return nativeResponseValue;
43648 // MUST_USE_RES struct LDKQuantity VerifiedInvoiceRequest_supported_quantity(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43650 export function VerifiedInvoiceRequest_supported_quantity(this_arg: bigint): bigint {
43651 if(!isWasmInitialized) {
43652 throw new Error("initializeWasm() must be awaited first!");
43654 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_supported_quantity(this_arg);
43655 return nativeResponseValue;
43657 // MUST_USE_RES struct LDKPublicKey VerifiedInvoiceRequest_signing_pubkey(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43659 export function VerifiedInvoiceRequest_signing_pubkey(this_arg: bigint): number {
43660 if(!isWasmInitialized) {
43661 throw new Error("initializeWasm() must be awaited first!");
43663 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_signing_pubkey(this_arg);
43664 return nativeResponseValue;
43666 // MUST_USE_RES struct LDKu8slice VerifiedInvoiceRequest_payer_metadata(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43668 export function VerifiedInvoiceRequest_payer_metadata(this_arg: bigint): number {
43669 if(!isWasmInitialized) {
43670 throw new Error("initializeWasm() must be awaited first!");
43672 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_metadata(this_arg);
43673 return nativeResponseValue;
43675 // MUST_USE_RES struct LDKThirtyTwoBytes VerifiedInvoiceRequest_chain(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43677 export function VerifiedInvoiceRequest_chain(this_arg: bigint): number {
43678 if(!isWasmInitialized) {
43679 throw new Error("initializeWasm() must be awaited first!");
43681 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_chain(this_arg);
43682 return nativeResponseValue;
43684 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_amount_msats(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43686 export function VerifiedInvoiceRequest_amount_msats(this_arg: bigint): bigint {
43687 if(!isWasmInitialized) {
43688 throw new Error("initializeWasm() must be awaited first!");
43690 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_amount_msats(this_arg);
43691 return nativeResponseValue;
43693 // MUST_USE_RES struct LDKInvoiceRequestFeatures VerifiedInvoiceRequest_invoice_request_features(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43695 export function VerifiedInvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
43696 if(!isWasmInitialized) {
43697 throw new Error("initializeWasm() must be awaited first!");
43699 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_invoice_request_features(this_arg);
43700 return nativeResponseValue;
43702 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_quantity(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43704 export function VerifiedInvoiceRequest_quantity(this_arg: bigint): bigint {
43705 if(!isWasmInitialized) {
43706 throw new Error("initializeWasm() must be awaited first!");
43708 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_quantity(this_arg);
43709 return nativeResponseValue;
43711 // MUST_USE_RES struct LDKPublicKey VerifiedInvoiceRequest_payer_id(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43713 export function VerifiedInvoiceRequest_payer_id(this_arg: bigint): number {
43714 if(!isWasmInitialized) {
43715 throw new Error("initializeWasm() must be awaited first!");
43717 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_id(this_arg);
43718 return nativeResponseValue;
43720 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_payer_note(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
43722 export function VerifiedInvoiceRequest_payer_note(this_arg: bigint): bigint {
43723 if(!isWasmInitialized) {
43724 throw new Error("initializeWasm() must be awaited first!");
43726 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_note(this_arg);
43727 return nativeResponseValue;
43729 // struct LDKCVec_u8Z UnsignedInvoiceRequest_write(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR obj);
43731 export function UnsignedInvoiceRequest_write(obj: bigint): number {
43732 if(!isWasmInitialized) {
43733 throw new Error("initializeWasm() must be awaited first!");
43735 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_write(obj);
43736 return nativeResponseValue;
43738 // struct LDKCVec_u8Z InvoiceRequest_write(const struct LDKInvoiceRequest *NONNULL_PTR obj);
43740 export function InvoiceRequest_write(obj: bigint): number {
43741 if(!isWasmInitialized) {
43742 throw new Error("initializeWasm() must be awaited first!");
43744 const nativeResponseValue = wasm.TS_InvoiceRequest_write(obj);
43745 return nativeResponseValue;
43747 // void TaggedHash_free(struct LDKTaggedHash this_obj);
43749 export function TaggedHash_free(this_obj: bigint): void {
43750 if(!isWasmInitialized) {
43751 throw new Error("initializeWasm() must be awaited first!");
43753 const nativeResponseValue = wasm.TS_TaggedHash_free(this_obj);
43754 // debug statements here
43756 // void Bolt12ParseError_free(struct LDKBolt12ParseError this_obj);
43758 export function Bolt12ParseError_free(this_obj: bigint): void {
43759 if(!isWasmInitialized) {
43760 throw new Error("initializeWasm() must be awaited first!");
43762 const nativeResponseValue = wasm.TS_Bolt12ParseError_free(this_obj);
43763 // debug statements here
43765 // uint64_t Bolt12ParseError_clone_ptr(LDKBolt12ParseError *NONNULL_PTR arg);
43767 export function Bolt12ParseError_clone_ptr(arg: bigint): bigint {
43768 if(!isWasmInitialized) {
43769 throw new Error("initializeWasm() must be awaited first!");
43771 const nativeResponseValue = wasm.TS_Bolt12ParseError_clone_ptr(arg);
43772 return nativeResponseValue;
43774 // struct LDKBolt12ParseError Bolt12ParseError_clone(const struct LDKBolt12ParseError *NONNULL_PTR orig);
43776 export function Bolt12ParseError_clone(orig: bigint): bigint {
43777 if(!isWasmInitialized) {
43778 throw new Error("initializeWasm() must be awaited first!");
43780 const nativeResponseValue = wasm.TS_Bolt12ParseError_clone(orig);
43781 return nativeResponseValue;
43783 // enum LDKBolt12SemanticError Bolt12SemanticError_clone(const enum LDKBolt12SemanticError *NONNULL_PTR orig);
43785 export function Bolt12SemanticError_clone(orig: bigint): Bolt12SemanticError {
43786 if(!isWasmInitialized) {
43787 throw new Error("initializeWasm() must be awaited first!");
43789 const nativeResponseValue = wasm.TS_Bolt12SemanticError_clone(orig);
43790 return nativeResponseValue;
43792 // enum LDKBolt12SemanticError Bolt12SemanticError_already_expired(void);
43794 export function Bolt12SemanticError_already_expired(): Bolt12SemanticError {
43795 if(!isWasmInitialized) {
43796 throw new Error("initializeWasm() must be awaited first!");
43798 const nativeResponseValue = wasm.TS_Bolt12SemanticError_already_expired();
43799 return nativeResponseValue;
43801 // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_chain(void);
43803 export function Bolt12SemanticError_unsupported_chain(): Bolt12SemanticError {
43804 if(!isWasmInitialized) {
43805 throw new Error("initializeWasm() must be awaited first!");
43807 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_chain();
43808 return nativeResponseValue;
43810 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_chain(void);
43812 export function Bolt12SemanticError_unexpected_chain(): Bolt12SemanticError {
43813 if(!isWasmInitialized) {
43814 throw new Error("initializeWasm() must be awaited first!");
43816 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_chain();
43817 return nativeResponseValue;
43819 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_amount(void);
43821 export function Bolt12SemanticError_missing_amount(): Bolt12SemanticError {
43822 if(!isWasmInitialized) {
43823 throw new Error("initializeWasm() must be awaited first!");
43825 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_amount();
43826 return nativeResponseValue;
43828 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_amount(void);
43830 export function Bolt12SemanticError_invalid_amount(): Bolt12SemanticError {
43831 if(!isWasmInitialized) {
43832 throw new Error("initializeWasm() must be awaited first!");
43834 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_amount();
43835 return nativeResponseValue;
43837 // enum LDKBolt12SemanticError Bolt12SemanticError_insufficient_amount(void);
43839 export function Bolt12SemanticError_insufficient_amount(): Bolt12SemanticError {
43840 if(!isWasmInitialized) {
43841 throw new Error("initializeWasm() must be awaited first!");
43843 const nativeResponseValue = wasm.TS_Bolt12SemanticError_insufficient_amount();
43844 return nativeResponseValue;
43846 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_amount(void);
43848 export function Bolt12SemanticError_unexpected_amount(): Bolt12SemanticError {
43849 if(!isWasmInitialized) {
43850 throw new Error("initializeWasm() must be awaited first!");
43852 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_amount();
43853 return nativeResponseValue;
43855 // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_currency(void);
43857 export function Bolt12SemanticError_unsupported_currency(): Bolt12SemanticError {
43858 if(!isWasmInitialized) {
43859 throw new Error("initializeWasm() must be awaited first!");
43861 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_currency();
43862 return nativeResponseValue;
43864 // enum LDKBolt12SemanticError Bolt12SemanticError_unknown_required_features(void);
43866 export function Bolt12SemanticError_unknown_required_features(): Bolt12SemanticError {
43867 if(!isWasmInitialized) {
43868 throw new Error("initializeWasm() must be awaited first!");
43870 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unknown_required_features();
43871 return nativeResponseValue;
43873 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_features(void);
43875 export function Bolt12SemanticError_unexpected_features(): Bolt12SemanticError {
43876 if(!isWasmInitialized) {
43877 throw new Error("initializeWasm() must be awaited first!");
43879 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_features();
43880 return nativeResponseValue;
43882 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_description(void);
43884 export function Bolt12SemanticError_missing_description(): Bolt12SemanticError {
43885 if(!isWasmInitialized) {
43886 throw new Error("initializeWasm() must be awaited first!");
43888 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_description();
43889 return nativeResponseValue;
43891 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signing_pubkey(void);
43893 export function Bolt12SemanticError_missing_signing_pubkey(): Bolt12SemanticError {
43894 if(!isWasmInitialized) {
43895 throw new Error("initializeWasm() must be awaited first!");
43897 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signing_pubkey();
43898 return nativeResponseValue;
43900 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_signing_pubkey(void);
43902 export function Bolt12SemanticError_invalid_signing_pubkey(): Bolt12SemanticError {
43903 if(!isWasmInitialized) {
43904 throw new Error("initializeWasm() must be awaited first!");
43906 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_signing_pubkey();
43907 return nativeResponseValue;
43909 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_signing_pubkey(void);
43911 export function Bolt12SemanticError_unexpected_signing_pubkey(): Bolt12SemanticError {
43912 if(!isWasmInitialized) {
43913 throw new Error("initializeWasm() must be awaited first!");
43915 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_signing_pubkey();
43916 return nativeResponseValue;
43918 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_quantity(void);
43920 export function Bolt12SemanticError_missing_quantity(): Bolt12SemanticError {
43921 if(!isWasmInitialized) {
43922 throw new Error("initializeWasm() must be awaited first!");
43924 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_quantity();
43925 return nativeResponseValue;
43927 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_quantity(void);
43929 export function Bolt12SemanticError_invalid_quantity(): Bolt12SemanticError {
43930 if(!isWasmInitialized) {
43931 throw new Error("initializeWasm() must be awaited first!");
43933 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_quantity();
43934 return nativeResponseValue;
43936 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_quantity(void);
43938 export function Bolt12SemanticError_unexpected_quantity(): Bolt12SemanticError {
43939 if(!isWasmInitialized) {
43940 throw new Error("initializeWasm() must be awaited first!");
43942 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_quantity();
43943 return nativeResponseValue;
43945 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_metadata(void);
43947 export function Bolt12SemanticError_invalid_metadata(): Bolt12SemanticError {
43948 if(!isWasmInitialized) {
43949 throw new Error("initializeWasm() must be awaited first!");
43951 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_metadata();
43952 return nativeResponseValue;
43954 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_metadata(void);
43956 export function Bolt12SemanticError_unexpected_metadata(): Bolt12SemanticError {
43957 if(!isWasmInitialized) {
43958 throw new Error("initializeWasm() must be awaited first!");
43960 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_metadata();
43961 return nativeResponseValue;
43963 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_metadata(void);
43965 export function Bolt12SemanticError_missing_payer_metadata(): Bolt12SemanticError {
43966 if(!isWasmInitialized) {
43967 throw new Error("initializeWasm() must be awaited first!");
43969 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_metadata();
43970 return nativeResponseValue;
43972 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_id(void);
43974 export function Bolt12SemanticError_missing_payer_id(): Bolt12SemanticError {
43975 if(!isWasmInitialized) {
43976 throw new Error("initializeWasm() must be awaited first!");
43978 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_id();
43979 return nativeResponseValue;
43981 // enum LDKBolt12SemanticError Bolt12SemanticError_duplicate_payment_id(void);
43983 export function Bolt12SemanticError_duplicate_payment_id(): Bolt12SemanticError {
43984 if(!isWasmInitialized) {
43985 throw new Error("initializeWasm() must be awaited first!");
43987 const nativeResponseValue = wasm.TS_Bolt12SemanticError_duplicate_payment_id();
43988 return nativeResponseValue;
43990 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_paths(void);
43992 export function Bolt12SemanticError_missing_paths(): Bolt12SemanticError {
43993 if(!isWasmInitialized) {
43994 throw new Error("initializeWasm() must be awaited first!");
43996 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_paths();
43997 return nativeResponseValue;
43999 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_pay_info(void);
44001 export function Bolt12SemanticError_invalid_pay_info(): Bolt12SemanticError {
44002 if(!isWasmInitialized) {
44003 throw new Error("initializeWasm() must be awaited first!");
44005 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_pay_info();
44006 return nativeResponseValue;
44008 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_creation_time(void);
44010 export function Bolt12SemanticError_missing_creation_time(): Bolt12SemanticError {
44011 if(!isWasmInitialized) {
44012 throw new Error("initializeWasm() must be awaited first!");
44014 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_creation_time();
44015 return nativeResponseValue;
44017 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payment_hash(void);
44019 export function Bolt12SemanticError_missing_payment_hash(): Bolt12SemanticError {
44020 if(!isWasmInitialized) {
44021 throw new Error("initializeWasm() must be awaited first!");
44023 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payment_hash();
44024 return nativeResponseValue;
44026 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signature(void);
44028 export function Bolt12SemanticError_missing_signature(): Bolt12SemanticError {
44029 if(!isWasmInitialized) {
44030 throw new Error("initializeWasm() must be awaited first!");
44032 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signature();
44033 return nativeResponseValue;
44035 // void Refund_free(struct LDKRefund this_obj);
44037 export function Refund_free(this_obj: bigint): void {
44038 if(!isWasmInitialized) {
44039 throw new Error("initializeWasm() must be awaited first!");
44041 const nativeResponseValue = wasm.TS_Refund_free(this_obj);
44042 // debug statements here
44044 // uint64_t Refund_clone_ptr(LDKRefund *NONNULL_PTR arg);
44046 export function Refund_clone_ptr(arg: bigint): bigint {
44047 if(!isWasmInitialized) {
44048 throw new Error("initializeWasm() must be awaited first!");
44050 const nativeResponseValue = wasm.TS_Refund_clone_ptr(arg);
44051 return nativeResponseValue;
44053 // struct LDKRefund Refund_clone(const struct LDKRefund *NONNULL_PTR orig);
44055 export function Refund_clone(orig: bigint): bigint {
44056 if(!isWasmInitialized) {
44057 throw new Error("initializeWasm() must be awaited first!");
44059 const nativeResponseValue = wasm.TS_Refund_clone(orig);
44060 return nativeResponseValue;
44062 // MUST_USE_RES struct LDKPrintableString Refund_description(const struct LDKRefund *NONNULL_PTR this_arg);
44064 export function Refund_description(this_arg: bigint): bigint {
44065 if(!isWasmInitialized) {
44066 throw new Error("initializeWasm() must be awaited first!");
44068 const nativeResponseValue = wasm.TS_Refund_description(this_arg);
44069 return nativeResponseValue;
44071 // MUST_USE_RES struct LDKCOption_u64Z Refund_absolute_expiry(const struct LDKRefund *NONNULL_PTR this_arg);
44073 export function Refund_absolute_expiry(this_arg: bigint): bigint {
44074 if(!isWasmInitialized) {
44075 throw new Error("initializeWasm() must be awaited first!");
44077 const nativeResponseValue = wasm.TS_Refund_absolute_expiry(this_arg);
44078 return nativeResponseValue;
44080 // MUST_USE_RES struct LDKPrintableString Refund_issuer(const struct LDKRefund *NONNULL_PTR this_arg);
44082 export function Refund_issuer(this_arg: bigint): bigint {
44083 if(!isWasmInitialized) {
44084 throw new Error("initializeWasm() must be awaited first!");
44086 const nativeResponseValue = wasm.TS_Refund_issuer(this_arg);
44087 return nativeResponseValue;
44089 // MUST_USE_RES struct LDKCVec_BlindedPathZ Refund_paths(const struct LDKRefund *NONNULL_PTR this_arg);
44091 export function Refund_paths(this_arg: bigint): number {
44092 if(!isWasmInitialized) {
44093 throw new Error("initializeWasm() must be awaited first!");
44095 const nativeResponseValue = wasm.TS_Refund_paths(this_arg);
44096 return nativeResponseValue;
44098 // MUST_USE_RES struct LDKu8slice Refund_payer_metadata(const struct LDKRefund *NONNULL_PTR this_arg);
44100 export function Refund_payer_metadata(this_arg: bigint): number {
44101 if(!isWasmInitialized) {
44102 throw new Error("initializeWasm() must be awaited first!");
44104 const nativeResponseValue = wasm.TS_Refund_payer_metadata(this_arg);
44105 return nativeResponseValue;
44107 // MUST_USE_RES struct LDKThirtyTwoBytes Refund_chain(const struct LDKRefund *NONNULL_PTR this_arg);
44109 export function Refund_chain(this_arg: bigint): number {
44110 if(!isWasmInitialized) {
44111 throw new Error("initializeWasm() must be awaited first!");
44113 const nativeResponseValue = wasm.TS_Refund_chain(this_arg);
44114 return nativeResponseValue;
44116 // MUST_USE_RES uint64_t Refund_amount_msats(const struct LDKRefund *NONNULL_PTR this_arg);
44118 export function Refund_amount_msats(this_arg: bigint): bigint {
44119 if(!isWasmInitialized) {
44120 throw new Error("initializeWasm() must be awaited first!");
44122 const nativeResponseValue = wasm.TS_Refund_amount_msats(this_arg);
44123 return nativeResponseValue;
44125 // MUST_USE_RES struct LDKInvoiceRequestFeatures Refund_features(const struct LDKRefund *NONNULL_PTR this_arg);
44127 export function Refund_features(this_arg: bigint): bigint {
44128 if(!isWasmInitialized) {
44129 throw new Error("initializeWasm() must be awaited first!");
44131 const nativeResponseValue = wasm.TS_Refund_features(this_arg);
44132 return nativeResponseValue;
44134 // MUST_USE_RES struct LDKCOption_u64Z Refund_quantity(const struct LDKRefund *NONNULL_PTR this_arg);
44136 export function Refund_quantity(this_arg: bigint): bigint {
44137 if(!isWasmInitialized) {
44138 throw new Error("initializeWasm() must be awaited first!");
44140 const nativeResponseValue = wasm.TS_Refund_quantity(this_arg);
44141 return nativeResponseValue;
44143 // MUST_USE_RES struct LDKPublicKey Refund_payer_id(const struct LDKRefund *NONNULL_PTR this_arg);
44145 export function Refund_payer_id(this_arg: bigint): number {
44146 if(!isWasmInitialized) {
44147 throw new Error("initializeWasm() must be awaited first!");
44149 const nativeResponseValue = wasm.TS_Refund_payer_id(this_arg);
44150 return nativeResponseValue;
44152 // MUST_USE_RES struct LDKPrintableString Refund_payer_note(const struct LDKRefund *NONNULL_PTR this_arg);
44154 export function Refund_payer_note(this_arg: bigint): bigint {
44155 if(!isWasmInitialized) {
44156 throw new Error("initializeWasm() must be awaited first!");
44158 const nativeResponseValue = wasm.TS_Refund_payer_note(this_arg);
44159 return nativeResponseValue;
44161 // struct LDKCVec_u8Z Refund_write(const struct LDKRefund *NONNULL_PTR obj);
44163 export function Refund_write(obj: bigint): number {
44164 if(!isWasmInitialized) {
44165 throw new Error("initializeWasm() must be awaited first!");
44167 const nativeResponseValue = wasm.TS_Refund_write(obj);
44168 return nativeResponseValue;
44170 // struct LDKCResult_RefundBolt12ParseErrorZ Refund_from_str(struct LDKStr s);
44172 export function Refund_from_str(s: number): bigint {
44173 if(!isWasmInitialized) {
44174 throw new Error("initializeWasm() must be awaited first!");
44176 const nativeResponseValue = wasm.TS_Refund_from_str(s);
44177 return nativeResponseValue;
44179 // enum LDKUtxoLookupError UtxoLookupError_clone(const enum LDKUtxoLookupError *NONNULL_PTR orig);
44181 export function UtxoLookupError_clone(orig: bigint): UtxoLookupError {
44182 if(!isWasmInitialized) {
44183 throw new Error("initializeWasm() must be awaited first!");
44185 const nativeResponseValue = wasm.TS_UtxoLookupError_clone(orig);
44186 return nativeResponseValue;
44188 // enum LDKUtxoLookupError UtxoLookupError_unknown_chain(void);
44190 export function UtxoLookupError_unknown_chain(): UtxoLookupError {
44191 if(!isWasmInitialized) {
44192 throw new Error("initializeWasm() must be awaited first!");
44194 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_chain();
44195 return nativeResponseValue;
44197 // enum LDKUtxoLookupError UtxoLookupError_unknown_tx(void);
44199 export function UtxoLookupError_unknown_tx(): UtxoLookupError {
44200 if(!isWasmInitialized) {
44201 throw new Error("initializeWasm() must be awaited first!");
44203 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_tx();
44204 return nativeResponseValue;
44206 // void UtxoResult_free(struct LDKUtxoResult this_ptr);
44208 export function UtxoResult_free(this_ptr: bigint): void {
44209 if(!isWasmInitialized) {
44210 throw new Error("initializeWasm() must be awaited first!");
44212 const nativeResponseValue = wasm.TS_UtxoResult_free(this_ptr);
44213 // debug statements here
44215 // uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg);
44217 export function UtxoResult_clone_ptr(arg: bigint): bigint {
44218 if(!isWasmInitialized) {
44219 throw new Error("initializeWasm() must be awaited first!");
44221 const nativeResponseValue = wasm.TS_UtxoResult_clone_ptr(arg);
44222 return nativeResponseValue;
44224 // struct LDKUtxoResult UtxoResult_clone(const struct LDKUtxoResult *NONNULL_PTR orig);
44226 export function UtxoResult_clone(orig: bigint): bigint {
44227 if(!isWasmInitialized) {
44228 throw new Error("initializeWasm() must be awaited first!");
44230 const nativeResponseValue = wasm.TS_UtxoResult_clone(orig);
44231 return nativeResponseValue;
44233 // struct LDKUtxoResult UtxoResult_sync(struct LDKCResult_TxOutUtxoLookupErrorZ a);
44235 export function UtxoResult_sync(a: bigint): bigint {
44236 if(!isWasmInitialized) {
44237 throw new Error("initializeWasm() must be awaited first!");
44239 const nativeResponseValue = wasm.TS_UtxoResult_sync(a);
44240 return nativeResponseValue;
44242 // struct LDKUtxoResult UtxoResult_async(struct LDKUtxoFuture a);
44244 export function UtxoResult_async(a: bigint): bigint {
44245 if(!isWasmInitialized) {
44246 throw new Error("initializeWasm() must be awaited first!");
44248 const nativeResponseValue = wasm.TS_UtxoResult_async(a);
44249 return nativeResponseValue;
44251 // void UtxoLookup_free(struct LDKUtxoLookup this_ptr);
44253 export function UtxoLookup_free(this_ptr: bigint): void {
44254 if(!isWasmInitialized) {
44255 throw new Error("initializeWasm() must be awaited first!");
44257 const nativeResponseValue = wasm.TS_UtxoLookup_free(this_ptr);
44258 // debug statements here
44260 // void UtxoFuture_free(struct LDKUtxoFuture this_obj);
44262 export function UtxoFuture_free(this_obj: bigint): void {
44263 if(!isWasmInitialized) {
44264 throw new Error("initializeWasm() must be awaited first!");
44266 const nativeResponseValue = wasm.TS_UtxoFuture_free(this_obj);
44267 // debug statements here
44269 // uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg);
44271 export function UtxoFuture_clone_ptr(arg: bigint): bigint {
44272 if(!isWasmInitialized) {
44273 throw new Error("initializeWasm() must be awaited first!");
44275 const nativeResponseValue = wasm.TS_UtxoFuture_clone_ptr(arg);
44276 return nativeResponseValue;
44278 // struct LDKUtxoFuture UtxoFuture_clone(const struct LDKUtxoFuture *NONNULL_PTR orig);
44280 export function UtxoFuture_clone(orig: bigint): bigint {
44281 if(!isWasmInitialized) {
44282 throw new Error("initializeWasm() must be awaited first!");
44284 const nativeResponseValue = wasm.TS_UtxoFuture_clone(orig);
44285 return nativeResponseValue;
44287 // MUST_USE_RES struct LDKUtxoFuture UtxoFuture_new(void);
44289 export function UtxoFuture_new(): bigint {
44290 if(!isWasmInitialized) {
44291 throw new Error("initializeWasm() must be awaited first!");
44293 const nativeResponseValue = wasm.TS_UtxoFuture_new();
44294 return nativeResponseValue;
44296 // void UtxoFuture_resolve_without_forwarding(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, struct LDKCResult_TxOutUtxoLookupErrorZ result);
44298 export function UtxoFuture_resolve_without_forwarding(this_arg: bigint, graph: bigint, result: bigint): void {
44299 if(!isWasmInitialized) {
44300 throw new Error("initializeWasm() must be awaited first!");
44302 const nativeResponseValue = wasm.TS_UtxoFuture_resolve_without_forwarding(this_arg, graph, result);
44303 // debug statements here
44305 // 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);
44307 export function UtxoFuture_resolve(this_arg: bigint, graph: bigint, gossip: bigint, result: bigint): void {
44308 if(!isWasmInitialized) {
44309 throw new Error("initializeWasm() must be awaited first!");
44311 const nativeResponseValue = wasm.TS_UtxoFuture_resolve(this_arg, graph, gossip, result);
44312 // debug statements here
44314 // void NodeId_free(struct LDKNodeId this_obj);
44316 export function NodeId_free(this_obj: bigint): void {
44317 if(!isWasmInitialized) {
44318 throw new Error("initializeWasm() must be awaited first!");
44320 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
44321 // debug statements here
44323 // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
44325 export function NodeId_clone_ptr(arg: bigint): bigint {
44326 if(!isWasmInitialized) {
44327 throw new Error("initializeWasm() must be awaited first!");
44329 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
44330 return nativeResponseValue;
44332 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
44334 export function NodeId_clone(orig: bigint): bigint {
44335 if(!isWasmInitialized) {
44336 throw new Error("initializeWasm() must be awaited first!");
44338 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
44339 return nativeResponseValue;
44341 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
44343 export function NodeId_from_pubkey(pubkey: number): bigint {
44344 if(!isWasmInitialized) {
44345 throw new Error("initializeWasm() must be awaited first!");
44347 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
44348 return nativeResponseValue;
44350 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
44352 export function NodeId_as_slice(this_arg: bigint): number {
44353 if(!isWasmInitialized) {
44354 throw new Error("initializeWasm() must be awaited first!");
44356 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
44357 return nativeResponseValue;
44359 // MUST_USE_RES struct LDKCResult_PublicKeySecp256k1ErrorZ NodeId_as_pubkey(const struct LDKNodeId *NONNULL_PTR this_arg);
44361 export function NodeId_as_pubkey(this_arg: bigint): bigint {
44362 if(!isWasmInitialized) {
44363 throw new Error("initializeWasm() must be awaited first!");
44365 const nativeResponseValue = wasm.TS_NodeId_as_pubkey(this_arg);
44366 return nativeResponseValue;
44368 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
44370 export function NodeId_hash(o: bigint): bigint {
44371 if(!isWasmInitialized) {
44372 throw new Error("initializeWasm() must be awaited first!");
44374 const nativeResponseValue = wasm.TS_NodeId_hash(o);
44375 return nativeResponseValue;
44377 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
44379 export function NodeId_write(obj: bigint): number {
44380 if(!isWasmInitialized) {
44381 throw new Error("initializeWasm() must be awaited first!");
44383 const nativeResponseValue = wasm.TS_NodeId_write(obj);
44384 return nativeResponseValue;
44386 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
44388 export function NodeId_read(ser: number): bigint {
44389 if(!isWasmInitialized) {
44390 throw new Error("initializeWasm() must be awaited first!");
44392 const nativeResponseValue = wasm.TS_NodeId_read(ser);
44393 return nativeResponseValue;
44395 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
44397 export function NetworkGraph_free(this_obj: bigint): void {
44398 if(!isWasmInitialized) {
44399 throw new Error("initializeWasm() must be awaited first!");
44401 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
44402 // debug statements here
44404 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
44406 export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
44407 if(!isWasmInitialized) {
44408 throw new Error("initializeWasm() must be awaited first!");
44410 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
44411 // debug statements here
44413 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
44415 export function NetworkUpdate_free(this_ptr: bigint): void {
44416 if(!isWasmInitialized) {
44417 throw new Error("initializeWasm() must be awaited first!");
44419 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
44420 // debug statements here
44422 // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
44424 export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
44425 if(!isWasmInitialized) {
44426 throw new Error("initializeWasm() must be awaited first!");
44428 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
44429 return nativeResponseValue;
44431 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
44433 export function NetworkUpdate_clone(orig: bigint): bigint {
44434 if(!isWasmInitialized) {
44435 throw new Error("initializeWasm() must be awaited first!");
44437 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
44438 return nativeResponseValue;
44440 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
44442 export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
44443 if(!isWasmInitialized) {
44444 throw new Error("initializeWasm() must be awaited first!");
44446 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
44447 return nativeResponseValue;
44449 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
44451 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
44452 if(!isWasmInitialized) {
44453 throw new Error("initializeWasm() must be awaited first!");
44455 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
44456 return nativeResponseValue;
44458 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
44460 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
44461 if(!isWasmInitialized) {
44462 throw new Error("initializeWasm() must be awaited first!");
44464 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
44465 return nativeResponseValue;
44467 // bool NetworkUpdate_eq(const struct LDKNetworkUpdate *NONNULL_PTR a, const struct LDKNetworkUpdate *NONNULL_PTR b);
44469 export function NetworkUpdate_eq(a: bigint, b: bigint): boolean {
44470 if(!isWasmInitialized) {
44471 throw new Error("initializeWasm() must be awaited first!");
44473 const nativeResponseValue = wasm.TS_NetworkUpdate_eq(a, b);
44474 return nativeResponseValue;
44476 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
44478 export function NetworkUpdate_write(obj: bigint): number {
44479 if(!isWasmInitialized) {
44480 throw new Error("initializeWasm() must be awaited first!");
44482 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
44483 return nativeResponseValue;
44485 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
44487 export function NetworkUpdate_read(ser: number): bigint {
44488 if(!isWasmInitialized) {
44489 throw new Error("initializeWasm() must be awaited first!");
44491 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
44492 return nativeResponseValue;
44494 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
44496 export function P2PGossipSync_free(this_obj: bigint): void {
44497 if(!isWasmInitialized) {
44498 throw new Error("initializeWasm() must be awaited first!");
44500 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
44501 // debug statements here
44503 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_UtxoLookupZ utxo_lookup, struct LDKLogger logger);
44505 export function P2PGossipSync_new(network_graph: bigint, utxo_lookup: bigint, logger: bigint): bigint {
44506 if(!isWasmInitialized) {
44507 throw new Error("initializeWasm() must be awaited first!");
44509 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, utxo_lookup, logger);
44510 return nativeResponseValue;
44512 // void P2PGossipSync_add_utxo_lookup(const struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_UtxoLookupZ utxo_lookup);
44514 export function P2PGossipSync_add_utxo_lookup(this_arg: bigint, utxo_lookup: bigint): void {
44515 if(!isWasmInitialized) {
44516 throw new Error("initializeWasm() must be awaited first!");
44518 const nativeResponseValue = wasm.TS_P2PGossipSync_add_utxo_lookup(this_arg, utxo_lookup);
44519 // debug statements here
44521 // void NetworkGraph_handle_network_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNetworkUpdate *NONNULL_PTR network_update);
44523 export function NetworkGraph_handle_network_update(this_arg: bigint, network_update: bigint): void {
44524 if(!isWasmInitialized) {
44525 throw new Error("initializeWasm() must be awaited first!");
44527 const nativeResponseValue = wasm.TS_NetworkGraph_handle_network_update(this_arg, network_update);
44528 // debug statements here
44530 // MUST_USE_RES struct LDKThirtyTwoBytes NetworkGraph_get_chain_hash(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
44532 export function NetworkGraph_get_chain_hash(this_arg: bigint): number {
44533 if(!isWasmInitialized) {
44534 throw new Error("initializeWasm() must be awaited first!");
44536 const nativeResponseValue = wasm.TS_NetworkGraph_get_chain_hash(this_arg);
44537 return nativeResponseValue;
44539 // struct LDKCResult_NoneLightningErrorZ verify_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
44541 export function verify_node_announcement(msg: bigint): bigint {
44542 if(!isWasmInitialized) {
44543 throw new Error("initializeWasm() must be awaited first!");
44545 const nativeResponseValue = wasm.TS_verify_node_announcement(msg);
44546 return nativeResponseValue;
44548 // struct LDKCResult_NoneLightningErrorZ verify_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
44550 export function verify_channel_announcement(msg: bigint): bigint {
44551 if(!isWasmInitialized) {
44552 throw new Error("initializeWasm() must be awaited first!");
44554 const nativeResponseValue = wasm.TS_verify_channel_announcement(msg);
44555 return nativeResponseValue;
44557 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
44559 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
44560 if(!isWasmInitialized) {
44561 throw new Error("initializeWasm() must be awaited first!");
44563 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
44564 return nativeResponseValue;
44566 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
44568 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
44569 if(!isWasmInitialized) {
44570 throw new Error("initializeWasm() must be awaited first!");
44572 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
44573 return nativeResponseValue;
44575 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
44577 export function ChannelUpdateInfo_free(this_obj: bigint): void {
44578 if(!isWasmInitialized) {
44579 throw new Error("initializeWasm() must be awaited first!");
44581 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
44582 // debug statements here
44584 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44586 export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
44587 if(!isWasmInitialized) {
44588 throw new Error("initializeWasm() must be awaited first!");
44590 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
44591 return nativeResponseValue;
44593 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
44595 export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
44596 if(!isWasmInitialized) {
44597 throw new Error("initializeWasm() must be awaited first!");
44599 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
44600 // debug statements here
44602 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44604 export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
44605 if(!isWasmInitialized) {
44606 throw new Error("initializeWasm() must be awaited first!");
44608 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
44609 return nativeResponseValue;
44611 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
44613 export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
44614 if(!isWasmInitialized) {
44615 throw new Error("initializeWasm() must be awaited first!");
44617 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
44618 // debug statements here
44620 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44622 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
44623 if(!isWasmInitialized) {
44624 throw new Error("initializeWasm() must be awaited first!");
44626 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
44627 return nativeResponseValue;
44629 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
44631 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
44632 if(!isWasmInitialized) {
44633 throw new Error("initializeWasm() must be awaited first!");
44635 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
44636 // debug statements here
44638 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44640 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
44641 if(!isWasmInitialized) {
44642 throw new Error("initializeWasm() must be awaited first!");
44644 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
44645 return nativeResponseValue;
44647 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
44649 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
44650 if(!isWasmInitialized) {
44651 throw new Error("initializeWasm() must be awaited first!");
44653 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
44654 // debug statements here
44656 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44658 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
44659 if(!isWasmInitialized) {
44660 throw new Error("initializeWasm() must be awaited first!");
44662 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
44663 return nativeResponseValue;
44665 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
44667 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
44668 if(!isWasmInitialized) {
44669 throw new Error("initializeWasm() must be awaited first!");
44671 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
44672 // debug statements here
44674 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44676 export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
44677 if(!isWasmInitialized) {
44678 throw new Error("initializeWasm() must be awaited first!");
44680 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
44681 return nativeResponseValue;
44683 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
44685 export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
44686 if(!isWasmInitialized) {
44687 throw new Error("initializeWasm() must be awaited first!");
44689 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
44690 // debug statements here
44692 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
44694 export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
44695 if(!isWasmInitialized) {
44696 throw new Error("initializeWasm() must be awaited first!");
44698 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
44699 return nativeResponseValue;
44701 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
44703 export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
44704 if(!isWasmInitialized) {
44705 throw new Error("initializeWasm() must be awaited first!");
44707 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
44708 // debug statements here
44710 // 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);
44712 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 {
44713 if(!isWasmInitialized) {
44714 throw new Error("initializeWasm() must be awaited first!");
44716 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);
44717 return nativeResponseValue;
44719 // uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
44721 export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
44722 if(!isWasmInitialized) {
44723 throw new Error("initializeWasm() must be awaited first!");
44725 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
44726 return nativeResponseValue;
44728 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
44730 export function ChannelUpdateInfo_clone(orig: bigint): bigint {
44731 if(!isWasmInitialized) {
44732 throw new Error("initializeWasm() must be awaited first!");
44734 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
44735 return nativeResponseValue;
44737 // bool ChannelUpdateInfo_eq(const struct LDKChannelUpdateInfo *NONNULL_PTR a, const struct LDKChannelUpdateInfo *NONNULL_PTR b);
44739 export function ChannelUpdateInfo_eq(a: bigint, b: bigint): boolean {
44740 if(!isWasmInitialized) {
44741 throw new Error("initializeWasm() must be awaited first!");
44743 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
44744 return nativeResponseValue;
44746 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
44748 export function ChannelUpdateInfo_write(obj: bigint): number {
44749 if(!isWasmInitialized) {
44750 throw new Error("initializeWasm() must be awaited first!");
44752 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
44753 return nativeResponseValue;
44755 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
44757 export function ChannelUpdateInfo_read(ser: number): bigint {
44758 if(!isWasmInitialized) {
44759 throw new Error("initializeWasm() must be awaited first!");
44761 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
44762 return nativeResponseValue;
44764 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
44766 export function ChannelInfo_free(this_obj: bigint): void {
44767 if(!isWasmInitialized) {
44768 throw new Error("initializeWasm() must be awaited first!");
44770 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
44771 // debug statements here
44773 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44775 export function ChannelInfo_get_features(this_ptr: bigint): bigint {
44776 if(!isWasmInitialized) {
44777 throw new Error("initializeWasm() must be awaited first!");
44779 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
44780 return nativeResponseValue;
44782 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
44784 export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
44785 if(!isWasmInitialized) {
44786 throw new Error("initializeWasm() must be awaited first!");
44788 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
44789 // debug statements here
44791 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44793 export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
44794 if(!isWasmInitialized) {
44795 throw new Error("initializeWasm() must be awaited first!");
44797 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
44798 return nativeResponseValue;
44800 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
44802 export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
44803 if(!isWasmInitialized) {
44804 throw new Error("initializeWasm() must be awaited first!");
44806 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
44807 // debug statements here
44809 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44811 export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
44812 if(!isWasmInitialized) {
44813 throw new Error("initializeWasm() must be awaited first!");
44815 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
44816 return nativeResponseValue;
44818 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
44820 export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
44821 if(!isWasmInitialized) {
44822 throw new Error("initializeWasm() must be awaited first!");
44824 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
44825 // debug statements here
44827 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44829 export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
44830 if(!isWasmInitialized) {
44831 throw new Error("initializeWasm() must be awaited first!");
44833 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
44834 return nativeResponseValue;
44836 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
44838 export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
44839 if(!isWasmInitialized) {
44840 throw new Error("initializeWasm() must be awaited first!");
44842 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
44843 // debug statements here
44845 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44847 export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
44848 if(!isWasmInitialized) {
44849 throw new Error("initializeWasm() must be awaited first!");
44851 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
44852 return nativeResponseValue;
44854 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
44856 export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
44857 if(!isWasmInitialized) {
44858 throw new Error("initializeWasm() must be awaited first!");
44860 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
44861 // debug statements here
44863 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44865 export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
44866 if(!isWasmInitialized) {
44867 throw new Error("initializeWasm() must be awaited first!");
44869 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
44870 return nativeResponseValue;
44872 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
44874 export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
44875 if(!isWasmInitialized) {
44876 throw new Error("initializeWasm() must be awaited first!");
44878 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
44879 // debug statements here
44881 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
44883 export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
44884 if(!isWasmInitialized) {
44885 throw new Error("initializeWasm() must be awaited first!");
44887 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
44888 return nativeResponseValue;
44890 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
44892 export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
44893 if(!isWasmInitialized) {
44894 throw new Error("initializeWasm() must be awaited first!");
44896 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
44897 // debug statements here
44899 // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
44901 export function ChannelInfo_clone_ptr(arg: bigint): bigint {
44902 if(!isWasmInitialized) {
44903 throw new Error("initializeWasm() must be awaited first!");
44905 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
44906 return nativeResponseValue;
44908 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
44910 export function ChannelInfo_clone(orig: bigint): bigint {
44911 if(!isWasmInitialized) {
44912 throw new Error("initializeWasm() must be awaited first!");
44914 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
44915 return nativeResponseValue;
44917 // bool ChannelInfo_eq(const struct LDKChannelInfo *NONNULL_PTR a, const struct LDKChannelInfo *NONNULL_PTR b);
44919 export function ChannelInfo_eq(a: bigint, b: bigint): boolean {
44920 if(!isWasmInitialized) {
44921 throw new Error("initializeWasm() must be awaited first!");
44923 const nativeResponseValue = wasm.TS_ChannelInfo_eq(a, b);
44924 return nativeResponseValue;
44926 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
44928 export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
44929 if(!isWasmInitialized) {
44930 throw new Error("initializeWasm() must be awaited first!");
44932 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
44933 return nativeResponseValue;
44935 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
44937 export function ChannelInfo_write(obj: bigint): number {
44938 if(!isWasmInitialized) {
44939 throw new Error("initializeWasm() must be awaited first!");
44941 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
44942 return nativeResponseValue;
44944 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
44946 export function ChannelInfo_read(ser: number): bigint {
44947 if(!isWasmInitialized) {
44948 throw new Error("initializeWasm() must be awaited first!");
44950 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
44951 return nativeResponseValue;
44953 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
44955 export function DirectedChannelInfo_free(this_obj: bigint): void {
44956 if(!isWasmInitialized) {
44957 throw new Error("initializeWasm() must be awaited first!");
44959 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
44960 // debug statements here
44962 // uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
44964 export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
44965 if(!isWasmInitialized) {
44966 throw new Error("initializeWasm() must be awaited first!");
44968 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
44969 return nativeResponseValue;
44971 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
44973 export function DirectedChannelInfo_clone(orig: bigint): bigint {
44974 if(!isWasmInitialized) {
44975 throw new Error("initializeWasm() must be awaited first!");
44977 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
44978 return nativeResponseValue;
44980 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
44982 export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
44983 if(!isWasmInitialized) {
44984 throw new Error("initializeWasm() must be awaited first!");
44986 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
44987 return nativeResponseValue;
44989 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
44991 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: bigint): bigint {
44992 if(!isWasmInitialized) {
44993 throw new Error("initializeWasm() must be awaited first!");
44995 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
44996 return nativeResponseValue;
44998 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
45000 export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
45001 if(!isWasmInitialized) {
45002 throw new Error("initializeWasm() must be awaited first!");
45004 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
45005 return nativeResponseValue;
45007 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
45009 export function EffectiveCapacity_free(this_ptr: bigint): void {
45010 if(!isWasmInitialized) {
45011 throw new Error("initializeWasm() must be awaited first!");
45013 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
45014 // debug statements here
45016 // uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
45018 export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
45019 if(!isWasmInitialized) {
45020 throw new Error("initializeWasm() must be awaited first!");
45022 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
45023 return nativeResponseValue;
45025 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
45027 export function EffectiveCapacity_clone(orig: bigint): bigint {
45028 if(!isWasmInitialized) {
45029 throw new Error("initializeWasm() must be awaited first!");
45031 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
45032 return nativeResponseValue;
45034 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
45036 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
45037 if(!isWasmInitialized) {
45038 throw new Error("initializeWasm() must be awaited first!");
45040 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
45041 return nativeResponseValue;
45043 // struct LDKEffectiveCapacity EffectiveCapacity_advertised_max_htlc(uint64_t amount_msat);
45045 export function EffectiveCapacity_advertised_max_htlc(amount_msat: bigint): bigint {
45046 if(!isWasmInitialized) {
45047 throw new Error("initializeWasm() must be awaited first!");
45049 const nativeResponseValue = wasm.TS_EffectiveCapacity_advertised_max_htlc(amount_msat);
45050 return nativeResponseValue;
45052 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, uint64_t htlc_maximum_msat);
45054 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
45055 if(!isWasmInitialized) {
45056 throw new Error("initializeWasm() must be awaited first!");
45058 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
45059 return nativeResponseValue;
45061 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
45063 export function EffectiveCapacity_infinite(): bigint {
45064 if(!isWasmInitialized) {
45065 throw new Error("initializeWasm() must be awaited first!");
45067 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
45068 return nativeResponseValue;
45070 // struct LDKEffectiveCapacity EffectiveCapacity_hint_max_htlc(uint64_t amount_msat);
45072 export function EffectiveCapacity_hint_max_htlc(amount_msat: bigint): bigint {
45073 if(!isWasmInitialized) {
45074 throw new Error("initializeWasm() must be awaited first!");
45076 const nativeResponseValue = wasm.TS_EffectiveCapacity_hint_max_htlc(amount_msat);
45077 return nativeResponseValue;
45079 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
45081 export function EffectiveCapacity_unknown(): bigint {
45082 if(!isWasmInitialized) {
45083 throw new Error("initializeWasm() must be awaited first!");
45085 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
45086 return nativeResponseValue;
45088 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
45090 export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
45091 if(!isWasmInitialized) {
45092 throw new Error("initializeWasm() must be awaited first!");
45094 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
45095 return nativeResponseValue;
45097 // void RoutingFees_free(struct LDKRoutingFees this_obj);
45099 export function RoutingFees_free(this_obj: bigint): void {
45100 if(!isWasmInitialized) {
45101 throw new Error("initializeWasm() must be awaited first!");
45103 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
45104 // debug statements here
45106 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
45108 export function RoutingFees_get_base_msat(this_ptr: bigint): number {
45109 if(!isWasmInitialized) {
45110 throw new Error("initializeWasm() must be awaited first!");
45112 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
45113 return nativeResponseValue;
45115 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
45117 export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
45118 if(!isWasmInitialized) {
45119 throw new Error("initializeWasm() must be awaited first!");
45121 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
45122 // debug statements here
45124 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
45126 export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
45127 if(!isWasmInitialized) {
45128 throw new Error("initializeWasm() must be awaited first!");
45130 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
45131 return nativeResponseValue;
45133 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
45135 export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
45136 if(!isWasmInitialized) {
45137 throw new Error("initializeWasm() must be awaited first!");
45139 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
45140 // debug statements here
45142 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
45144 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
45145 if(!isWasmInitialized) {
45146 throw new Error("initializeWasm() must be awaited first!");
45148 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
45149 return nativeResponseValue;
45151 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
45153 export function RoutingFees_eq(a: bigint, b: bigint): boolean {
45154 if(!isWasmInitialized) {
45155 throw new Error("initializeWasm() must be awaited first!");
45157 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
45158 return nativeResponseValue;
45160 // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
45162 export function RoutingFees_clone_ptr(arg: bigint): bigint {
45163 if(!isWasmInitialized) {
45164 throw new Error("initializeWasm() must be awaited first!");
45166 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
45167 return nativeResponseValue;
45169 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
45171 export function RoutingFees_clone(orig: bigint): bigint {
45172 if(!isWasmInitialized) {
45173 throw new Error("initializeWasm() must be awaited first!");
45175 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
45176 return nativeResponseValue;
45178 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
45180 export function RoutingFees_hash(o: bigint): bigint {
45181 if(!isWasmInitialized) {
45182 throw new Error("initializeWasm() must be awaited first!");
45184 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
45185 return nativeResponseValue;
45187 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
45189 export function RoutingFees_write(obj: bigint): number {
45190 if(!isWasmInitialized) {
45191 throw new Error("initializeWasm() must be awaited first!");
45193 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
45194 return nativeResponseValue;
45196 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
45198 export function RoutingFees_read(ser: number): bigint {
45199 if(!isWasmInitialized) {
45200 throw new Error("initializeWasm() must be awaited first!");
45202 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
45203 return nativeResponseValue;
45205 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
45207 export function NodeAnnouncementInfo_free(this_obj: bigint): void {
45208 if(!isWasmInitialized) {
45209 throw new Error("initializeWasm() must be awaited first!");
45211 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
45212 // debug statements here
45214 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
45216 export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
45217 if(!isWasmInitialized) {
45218 throw new Error("initializeWasm() must be awaited first!");
45220 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
45221 return nativeResponseValue;
45223 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
45225 export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
45226 if(!isWasmInitialized) {
45227 throw new Error("initializeWasm() must be awaited first!");
45229 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
45230 // debug statements here
45232 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
45234 export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
45235 if(!isWasmInitialized) {
45236 throw new Error("initializeWasm() must be awaited first!");
45238 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
45239 return nativeResponseValue;
45241 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
45243 export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
45244 if(!isWasmInitialized) {
45245 throw new Error("initializeWasm() must be awaited first!");
45247 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
45248 // debug statements here
45250 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
45252 export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
45253 if(!isWasmInitialized) {
45254 throw new Error("initializeWasm() must be awaited first!");
45256 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
45257 return nativeResponseValue;
45259 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
45261 export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
45262 if(!isWasmInitialized) {
45263 throw new Error("initializeWasm() must be awaited first!");
45265 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
45266 // debug statements here
45268 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
45270 export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
45271 if(!isWasmInitialized) {
45272 throw new Error("initializeWasm() must be awaited first!");
45274 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
45275 return nativeResponseValue;
45277 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
45279 export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
45280 if(!isWasmInitialized) {
45281 throw new Error("initializeWasm() must be awaited first!");
45283 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
45284 // debug statements here
45286 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
45288 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
45289 if(!isWasmInitialized) {
45290 throw new Error("initializeWasm() must be awaited first!");
45292 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
45293 return nativeResponseValue;
45295 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
45297 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
45298 if(!isWasmInitialized) {
45299 throw new Error("initializeWasm() must be awaited first!");
45301 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
45302 // debug statements here
45304 // 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);
45306 export function NodeAnnouncementInfo_new(features_arg: bigint, last_update_arg: number, rgb_arg: number, alias_arg: bigint, announcement_message_arg: bigint): bigint {
45307 if(!isWasmInitialized) {
45308 throw new Error("initializeWasm() must be awaited first!");
45310 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, announcement_message_arg);
45311 return nativeResponseValue;
45313 // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
45315 export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
45316 if(!isWasmInitialized) {
45317 throw new Error("initializeWasm() must be awaited first!");
45319 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
45320 return nativeResponseValue;
45322 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
45324 export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
45325 if(!isWasmInitialized) {
45326 throw new Error("initializeWasm() must be awaited first!");
45328 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
45329 return nativeResponseValue;
45331 // bool NodeAnnouncementInfo_eq(const struct LDKNodeAnnouncementInfo *NONNULL_PTR a, const struct LDKNodeAnnouncementInfo *NONNULL_PTR b);
45333 export function NodeAnnouncementInfo_eq(a: bigint, b: bigint): boolean {
45334 if(!isWasmInitialized) {
45335 throw new Error("initializeWasm() must be awaited first!");
45337 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_eq(a, b);
45338 return nativeResponseValue;
45340 // MUST_USE_RES struct LDKCVec_SocketAddressZ NodeAnnouncementInfo_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
45342 export function NodeAnnouncementInfo_addresses(this_arg: bigint): number {
45343 if(!isWasmInitialized) {
45344 throw new Error("initializeWasm() must be awaited first!");
45346 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_addresses(this_arg);
45347 return nativeResponseValue;
45349 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
45351 export function NodeAnnouncementInfo_write(obj: bigint): number {
45352 if(!isWasmInitialized) {
45353 throw new Error("initializeWasm() must be awaited first!");
45355 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
45356 return nativeResponseValue;
45358 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
45360 export function NodeAnnouncementInfo_read(ser: number): bigint {
45361 if(!isWasmInitialized) {
45362 throw new Error("initializeWasm() must be awaited first!");
45364 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
45365 return nativeResponseValue;
45367 // void NodeAlias_free(struct LDKNodeAlias this_obj);
45369 export function NodeAlias_free(this_obj: bigint): void {
45370 if(!isWasmInitialized) {
45371 throw new Error("initializeWasm() must be awaited first!");
45373 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
45374 // debug statements here
45376 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
45378 export function NodeAlias_get_a(this_ptr: bigint): number {
45379 if(!isWasmInitialized) {
45380 throw new Error("initializeWasm() must be awaited first!");
45382 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
45383 return nativeResponseValue;
45385 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
45387 export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
45388 if(!isWasmInitialized) {
45389 throw new Error("initializeWasm() must be awaited first!");
45391 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
45392 // debug statements here
45394 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
45396 export function NodeAlias_new(a_arg: number): bigint {
45397 if(!isWasmInitialized) {
45398 throw new Error("initializeWasm() must be awaited first!");
45400 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
45401 return nativeResponseValue;
45403 // uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
45405 export function NodeAlias_clone_ptr(arg: bigint): bigint {
45406 if(!isWasmInitialized) {
45407 throw new Error("initializeWasm() must be awaited first!");
45409 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
45410 return nativeResponseValue;
45412 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
45414 export function NodeAlias_clone(orig: bigint): bigint {
45415 if(!isWasmInitialized) {
45416 throw new Error("initializeWasm() must be awaited first!");
45418 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
45419 return nativeResponseValue;
45421 // bool NodeAlias_eq(const struct LDKNodeAlias *NONNULL_PTR a, const struct LDKNodeAlias *NONNULL_PTR b);
45423 export function NodeAlias_eq(a: bigint, b: bigint): boolean {
45424 if(!isWasmInitialized) {
45425 throw new Error("initializeWasm() must be awaited first!");
45427 const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
45428 return nativeResponseValue;
45430 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
45432 export function NodeAlias_write(obj: bigint): number {
45433 if(!isWasmInitialized) {
45434 throw new Error("initializeWasm() must be awaited first!");
45436 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
45437 return nativeResponseValue;
45439 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
45441 export function NodeAlias_read(ser: number): bigint {
45442 if(!isWasmInitialized) {
45443 throw new Error("initializeWasm() must be awaited first!");
45445 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
45446 return nativeResponseValue;
45448 // void NodeInfo_free(struct LDKNodeInfo this_obj);
45450 export function NodeInfo_free(this_obj: bigint): void {
45451 if(!isWasmInitialized) {
45452 throw new Error("initializeWasm() must be awaited first!");
45454 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
45455 // debug statements here
45457 // struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
45459 export function NodeInfo_get_channels(this_ptr: bigint): number {
45460 if(!isWasmInitialized) {
45461 throw new Error("initializeWasm() must be awaited first!");
45463 const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
45464 return nativeResponseValue;
45466 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
45468 export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
45469 if(!isWasmInitialized) {
45470 throw new Error("initializeWasm() must be awaited first!");
45472 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
45473 // debug statements here
45475 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
45477 export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
45478 if(!isWasmInitialized) {
45479 throw new Error("initializeWasm() must be awaited first!");
45481 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
45482 return nativeResponseValue;
45484 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
45486 export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
45487 if(!isWasmInitialized) {
45488 throw new Error("initializeWasm() must be awaited first!");
45490 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
45491 // debug statements here
45493 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
45495 export function NodeInfo_new(channels_arg: number, announcement_info_arg: bigint): bigint {
45496 if(!isWasmInitialized) {
45497 throw new Error("initializeWasm() must be awaited first!");
45499 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, announcement_info_arg);
45500 return nativeResponseValue;
45502 // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
45504 export function NodeInfo_clone_ptr(arg: bigint): bigint {
45505 if(!isWasmInitialized) {
45506 throw new Error("initializeWasm() must be awaited first!");
45508 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
45509 return nativeResponseValue;
45511 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
45513 export function NodeInfo_clone(orig: bigint): bigint {
45514 if(!isWasmInitialized) {
45515 throw new Error("initializeWasm() must be awaited first!");
45517 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
45518 return nativeResponseValue;
45520 // bool NodeInfo_eq(const struct LDKNodeInfo *NONNULL_PTR a, const struct LDKNodeInfo *NONNULL_PTR b);
45522 export function NodeInfo_eq(a: bigint, b: bigint): boolean {
45523 if(!isWasmInitialized) {
45524 throw new Error("initializeWasm() must be awaited first!");
45526 const nativeResponseValue = wasm.TS_NodeInfo_eq(a, b);
45527 return nativeResponseValue;
45529 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
45531 export function NodeInfo_write(obj: bigint): number {
45532 if(!isWasmInitialized) {
45533 throw new Error("initializeWasm() must be awaited first!");
45535 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
45536 return nativeResponseValue;
45538 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
45540 export function NodeInfo_read(ser: number): bigint {
45541 if(!isWasmInitialized) {
45542 throw new Error("initializeWasm() must be awaited first!");
45544 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
45545 return nativeResponseValue;
45547 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
45549 export function NetworkGraph_write(obj: bigint): number {
45550 if(!isWasmInitialized) {
45551 throw new Error("initializeWasm() must be awaited first!");
45553 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
45554 return nativeResponseValue;
45556 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
45558 export function NetworkGraph_read(ser: number, arg: bigint): bigint {
45559 if(!isWasmInitialized) {
45560 throw new Error("initializeWasm() must be awaited first!");
45562 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
45563 return nativeResponseValue;
45565 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(enum LDKNetwork network, struct LDKLogger logger);
45567 export function NetworkGraph_new(network: Network, logger: bigint): bigint {
45568 if(!isWasmInitialized) {
45569 throw new Error("initializeWasm() must be awaited first!");
45571 const nativeResponseValue = wasm.TS_NetworkGraph_new(network, logger);
45572 return nativeResponseValue;
45574 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
45576 export function NetworkGraph_read_only(this_arg: bigint): bigint {
45577 if(!isWasmInitialized) {
45578 throw new Error("initializeWasm() must be awaited first!");
45580 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
45581 return nativeResponseValue;
45583 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
45585 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
45586 if(!isWasmInitialized) {
45587 throw new Error("initializeWasm() must be awaited first!");
45589 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
45590 return nativeResponseValue;
45592 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
45594 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
45595 if(!isWasmInitialized) {
45596 throw new Error("initializeWasm() must be awaited first!");
45598 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
45599 // debug statements here
45601 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
45603 export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
45604 if(!isWasmInitialized) {
45605 throw new Error("initializeWasm() must be awaited first!");
45607 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
45608 return nativeResponseValue;
45610 // 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);
45612 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
45613 if(!isWasmInitialized) {
45614 throw new Error("initializeWasm() must be awaited first!");
45616 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
45617 return nativeResponseValue;
45619 // 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);
45621 export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
45622 if(!isWasmInitialized) {
45623 throw new Error("initializeWasm() must be awaited first!");
45625 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, utxo_lookup);
45626 return nativeResponseValue;
45628 // 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);
45630 export function NetworkGraph_update_channel_from_announcement_no_lookup(this_arg: bigint, msg: bigint): bigint {
45631 if(!isWasmInitialized) {
45632 throw new Error("initializeWasm() must be awaited first!");
45634 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement_no_lookup(this_arg, msg);
45635 return nativeResponseValue;
45637 // 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);
45639 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
45640 if(!isWasmInitialized) {
45641 throw new Error("initializeWasm() must be awaited first!");
45643 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, utxo_lookup);
45644 return nativeResponseValue;
45646 // 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);
45648 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 {
45649 if(!isWasmInitialized) {
45650 throw new Error("initializeWasm() must be awaited first!");
45652 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
45653 return nativeResponseValue;
45655 // void NetworkGraph_channel_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
45657 export function NetworkGraph_channel_failed_permanent(this_arg: bigint, short_channel_id: bigint): void {
45658 if(!isWasmInitialized) {
45659 throw new Error("initializeWasm() must be awaited first!");
45661 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed_permanent(this_arg, short_channel_id);
45662 // debug statements here
45664 // void NetworkGraph_node_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
45666 export function NetworkGraph_node_failed_permanent(this_arg: bigint, node_id: number): void {
45667 if(!isWasmInitialized) {
45668 throw new Error("initializeWasm() must be awaited first!");
45670 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed_permanent(this_arg, node_id);
45671 // debug statements here
45673 // void NetworkGraph_remove_stale_channels_and_tracking_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
45675 export function NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg: bigint, current_time_unix: bigint): void {
45676 if(!isWasmInitialized) {
45677 throw new Error("initializeWasm() must be awaited first!");
45679 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg, current_time_unix);
45680 // debug statements here
45682 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
45684 export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
45685 if(!isWasmInitialized) {
45686 throw new Error("initializeWasm() must be awaited first!");
45688 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
45689 return nativeResponseValue;
45691 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
45693 export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
45694 if(!isWasmInitialized) {
45695 throw new Error("initializeWasm() must be awaited first!");
45697 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
45698 return nativeResponseValue;
45700 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_verify_channel_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
45702 export function NetworkGraph_verify_channel_update(this_arg: bigint, msg: bigint): bigint {
45703 if(!isWasmInitialized) {
45704 throw new Error("initializeWasm() must be awaited first!");
45706 const nativeResponseValue = wasm.TS_NetworkGraph_verify_channel_update(this_arg, msg);
45707 return nativeResponseValue;
45709 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
45711 export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
45712 if(!isWasmInitialized) {
45713 throw new Error("initializeWasm() must be awaited first!");
45715 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
45716 return nativeResponseValue;
45718 // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
45720 export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
45721 if(!isWasmInitialized) {
45722 throw new Error("initializeWasm() must be awaited first!");
45724 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
45725 return nativeResponseValue;
45727 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
45729 export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
45730 if(!isWasmInitialized) {
45731 throw new Error("initializeWasm() must be awaited first!");
45733 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
45734 return nativeResponseValue;
45736 // MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
45738 export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
45739 if(!isWasmInitialized) {
45740 throw new Error("initializeWasm() must be awaited first!");
45742 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
45743 return nativeResponseValue;
45745 // MUST_USE_RES struct LDKCOption_CVec_SocketAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
45747 export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
45748 if(!isWasmInitialized) {
45749 throw new Error("initializeWasm() must be awaited first!");
45751 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
45752 return nativeResponseValue;
45754 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
45756 export function DefaultRouter_free(this_obj: bigint): void {
45757 if(!isWasmInitialized) {
45758 throw new Error("initializeWasm() must be awaited first!");
45760 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
45761 // debug statements here
45763 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes, struct LDKLockableScore scorer, struct LDKProbabilisticScoringFeeParameters score_params);
45765 export function DefaultRouter_new(network_graph: bigint, logger: bigint, random_seed_bytes: number, scorer: bigint, score_params: bigint): bigint {
45766 if(!isWasmInitialized) {
45767 throw new Error("initializeWasm() must be awaited first!");
45769 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes, scorer, score_params);
45770 return nativeResponseValue;
45772 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
45774 export function DefaultRouter_as_Router(this_arg: bigint): bigint {
45775 if(!isWasmInitialized) {
45776 throw new Error("initializeWasm() must be awaited first!");
45778 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
45779 return nativeResponseValue;
45781 // void Router_free(struct LDKRouter this_ptr);
45783 export function Router_free(this_ptr: bigint): void {
45784 if(!isWasmInitialized) {
45785 throw new Error("initializeWasm() must be awaited first!");
45787 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
45788 // debug statements here
45790 // void ScorerAccountingForInFlightHtlcs_free(struct LDKScorerAccountingForInFlightHtlcs this_obj);
45792 export function ScorerAccountingForInFlightHtlcs_free(this_obj: bigint): void {
45793 if(!isWasmInitialized) {
45794 throw new Error("initializeWasm() must be awaited first!");
45796 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_free(this_obj);
45797 // debug statements here
45799 // MUST_USE_RES struct LDKScorerAccountingForInFlightHtlcs ScorerAccountingForInFlightHtlcs_new(struct LDKScoreLookUp scorer, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs);
45801 export function ScorerAccountingForInFlightHtlcs_new(scorer: bigint, inflight_htlcs: bigint): bigint {
45802 if(!isWasmInitialized) {
45803 throw new Error("initializeWasm() must be awaited first!");
45805 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_new(scorer, inflight_htlcs);
45806 return nativeResponseValue;
45808 // struct LDKScoreLookUp ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR this_arg);
45810 export function ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(this_arg: bigint): bigint {
45811 if(!isWasmInitialized) {
45812 throw new Error("initializeWasm() must be awaited first!");
45814 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(this_arg);
45815 return nativeResponseValue;
45817 // void InFlightHtlcs_free(struct LDKInFlightHtlcs this_obj);
45819 export function InFlightHtlcs_free(this_obj: bigint): void {
45820 if(!isWasmInitialized) {
45821 throw new Error("initializeWasm() must be awaited first!");
45823 const nativeResponseValue = wasm.TS_InFlightHtlcs_free(this_obj);
45824 // debug statements here
45826 // uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg);
45828 export function InFlightHtlcs_clone_ptr(arg: bigint): bigint {
45829 if(!isWasmInitialized) {
45830 throw new Error("initializeWasm() must be awaited first!");
45832 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone_ptr(arg);
45833 return nativeResponseValue;
45835 // struct LDKInFlightHtlcs InFlightHtlcs_clone(const struct LDKInFlightHtlcs *NONNULL_PTR orig);
45837 export function InFlightHtlcs_clone(orig: bigint): bigint {
45838 if(!isWasmInitialized) {
45839 throw new Error("initializeWasm() must be awaited first!");
45841 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone(orig);
45842 return nativeResponseValue;
45844 // MUST_USE_RES struct LDKInFlightHtlcs InFlightHtlcs_new(void);
45846 export function InFlightHtlcs_new(): bigint {
45847 if(!isWasmInitialized) {
45848 throw new Error("initializeWasm() must be awaited first!");
45850 const nativeResponseValue = wasm.TS_InFlightHtlcs_new();
45851 return nativeResponseValue;
45853 // void InFlightHtlcs_process_path(struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, struct LDKPublicKey payer_node_id);
45855 export function InFlightHtlcs_process_path(this_arg: bigint, path: bigint, payer_node_id: number): void {
45856 if(!isWasmInitialized) {
45857 throw new Error("initializeWasm() must be awaited first!");
45859 const nativeResponseValue = wasm.TS_InFlightHtlcs_process_path(this_arg, path, payer_node_id);
45860 // debug statements here
45862 // 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);
45864 export function InFlightHtlcs_add_inflight_htlc(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint, used_msat: bigint): void {
45865 if(!isWasmInitialized) {
45866 throw new Error("initializeWasm() must be awaited first!");
45868 const nativeResponseValue = wasm.TS_InFlightHtlcs_add_inflight_htlc(this_arg, source, target, channel_scid, used_msat);
45869 // debug statements here
45871 // 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);
45873 export function InFlightHtlcs_used_liquidity_msat(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint): bigint {
45874 if(!isWasmInitialized) {
45875 throw new Error("initializeWasm() must be awaited first!");
45877 const nativeResponseValue = wasm.TS_InFlightHtlcs_used_liquidity_msat(this_arg, source, target, channel_scid);
45878 return nativeResponseValue;
45880 // struct LDKCVec_u8Z InFlightHtlcs_write(const struct LDKInFlightHtlcs *NONNULL_PTR obj);
45882 export function InFlightHtlcs_write(obj: bigint): number {
45883 if(!isWasmInitialized) {
45884 throw new Error("initializeWasm() must be awaited first!");
45886 const nativeResponseValue = wasm.TS_InFlightHtlcs_write(obj);
45887 return nativeResponseValue;
45889 // struct LDKCResult_InFlightHtlcsDecodeErrorZ InFlightHtlcs_read(struct LDKu8slice ser);
45891 export function InFlightHtlcs_read(ser: number): bigint {
45892 if(!isWasmInitialized) {
45893 throw new Error("initializeWasm() must be awaited first!");
45895 const nativeResponseValue = wasm.TS_InFlightHtlcs_read(ser);
45896 return nativeResponseValue;
45898 // void RouteHop_free(struct LDKRouteHop this_obj);
45900 export function RouteHop_free(this_obj: bigint): void {
45901 if(!isWasmInitialized) {
45902 throw new Error("initializeWasm() must be awaited first!");
45904 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
45905 // debug statements here
45907 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45909 export function RouteHop_get_pubkey(this_ptr: bigint): number {
45910 if(!isWasmInitialized) {
45911 throw new Error("initializeWasm() must be awaited first!");
45913 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
45914 return nativeResponseValue;
45916 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
45918 export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
45919 if(!isWasmInitialized) {
45920 throw new Error("initializeWasm() must be awaited first!");
45922 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
45923 // debug statements here
45925 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45927 export function RouteHop_get_node_features(this_ptr: bigint): bigint {
45928 if(!isWasmInitialized) {
45929 throw new Error("initializeWasm() must be awaited first!");
45931 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
45932 return nativeResponseValue;
45934 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
45936 export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
45937 if(!isWasmInitialized) {
45938 throw new Error("initializeWasm() must be awaited first!");
45940 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
45941 // debug statements here
45943 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45945 export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
45946 if(!isWasmInitialized) {
45947 throw new Error("initializeWasm() must be awaited first!");
45949 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
45950 return nativeResponseValue;
45952 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
45954 export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
45955 if(!isWasmInitialized) {
45956 throw new Error("initializeWasm() must be awaited first!");
45958 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
45959 // debug statements here
45961 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45963 export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
45964 if(!isWasmInitialized) {
45965 throw new Error("initializeWasm() must be awaited first!");
45967 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
45968 return nativeResponseValue;
45970 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
45972 export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
45973 if(!isWasmInitialized) {
45974 throw new Error("initializeWasm() must be awaited first!");
45976 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
45977 // debug statements here
45979 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45981 export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
45982 if(!isWasmInitialized) {
45983 throw new Error("initializeWasm() must be awaited first!");
45985 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
45986 return nativeResponseValue;
45988 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
45990 export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
45991 if(!isWasmInitialized) {
45992 throw new Error("initializeWasm() must be awaited first!");
45994 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
45995 // debug statements here
45997 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
45999 export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
46000 if(!isWasmInitialized) {
46001 throw new Error("initializeWasm() must be awaited first!");
46003 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
46004 return nativeResponseValue;
46006 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
46008 export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
46009 if(!isWasmInitialized) {
46010 throw new Error("initializeWasm() must be awaited first!");
46012 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
46013 // debug statements here
46015 // bool RouteHop_get_maybe_announced_channel(const struct LDKRouteHop *NONNULL_PTR this_ptr);
46017 export function RouteHop_get_maybe_announced_channel(this_ptr: bigint): boolean {
46018 if(!isWasmInitialized) {
46019 throw new Error("initializeWasm() must be awaited first!");
46021 const nativeResponseValue = wasm.TS_RouteHop_get_maybe_announced_channel(this_ptr);
46022 return nativeResponseValue;
46024 // void RouteHop_set_maybe_announced_channel(struct LDKRouteHop *NONNULL_PTR this_ptr, bool val);
46026 export function RouteHop_set_maybe_announced_channel(this_ptr: bigint, val: boolean): void {
46027 if(!isWasmInitialized) {
46028 throw new Error("initializeWasm() must be awaited first!");
46030 const nativeResponseValue = wasm.TS_RouteHop_set_maybe_announced_channel(this_ptr, val);
46031 // debug statements here
46033 // 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);
46035 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 {
46036 if(!isWasmInitialized) {
46037 throw new Error("initializeWasm() must be awaited first!");
46039 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);
46040 return nativeResponseValue;
46042 // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
46044 export function RouteHop_clone_ptr(arg: bigint): bigint {
46045 if(!isWasmInitialized) {
46046 throw new Error("initializeWasm() must be awaited first!");
46048 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
46049 return nativeResponseValue;
46051 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
46053 export function RouteHop_clone(orig: bigint): bigint {
46054 if(!isWasmInitialized) {
46055 throw new Error("initializeWasm() must be awaited first!");
46057 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
46058 return nativeResponseValue;
46060 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
46062 export function RouteHop_hash(o: bigint): bigint {
46063 if(!isWasmInitialized) {
46064 throw new Error("initializeWasm() must be awaited first!");
46066 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
46067 return nativeResponseValue;
46069 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
46071 export function RouteHop_eq(a: bigint, b: bigint): boolean {
46072 if(!isWasmInitialized) {
46073 throw new Error("initializeWasm() must be awaited first!");
46075 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
46076 return nativeResponseValue;
46078 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
46080 export function RouteHop_write(obj: bigint): number {
46081 if(!isWasmInitialized) {
46082 throw new Error("initializeWasm() must be awaited first!");
46084 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
46085 return nativeResponseValue;
46087 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
46089 export function RouteHop_read(ser: number): bigint {
46090 if(!isWasmInitialized) {
46091 throw new Error("initializeWasm() must be awaited first!");
46093 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
46094 return nativeResponseValue;
46096 // void BlindedTail_free(struct LDKBlindedTail this_obj);
46098 export function BlindedTail_free(this_obj: bigint): void {
46099 if(!isWasmInitialized) {
46100 throw new Error("initializeWasm() must be awaited first!");
46102 const nativeResponseValue = wasm.TS_BlindedTail_free(this_obj);
46103 // debug statements here
46105 // struct LDKCVec_BlindedHopZ BlindedTail_get_hops(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
46107 export function BlindedTail_get_hops(this_ptr: bigint): number {
46108 if(!isWasmInitialized) {
46109 throw new Error("initializeWasm() must be awaited first!");
46111 const nativeResponseValue = wasm.TS_BlindedTail_get_hops(this_ptr);
46112 return nativeResponseValue;
46114 // void BlindedTail_set_hops(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKCVec_BlindedHopZ val);
46116 export function BlindedTail_set_hops(this_ptr: bigint, val: number): void {
46117 if(!isWasmInitialized) {
46118 throw new Error("initializeWasm() must be awaited first!");
46120 const nativeResponseValue = wasm.TS_BlindedTail_set_hops(this_ptr, val);
46121 // debug statements here
46123 // struct LDKPublicKey BlindedTail_get_blinding_point(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
46125 export function BlindedTail_get_blinding_point(this_ptr: bigint): number {
46126 if(!isWasmInitialized) {
46127 throw new Error("initializeWasm() must be awaited first!");
46129 const nativeResponseValue = wasm.TS_BlindedTail_get_blinding_point(this_ptr);
46130 return nativeResponseValue;
46132 // void BlindedTail_set_blinding_point(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKPublicKey val);
46134 export function BlindedTail_set_blinding_point(this_ptr: bigint, val: number): void {
46135 if(!isWasmInitialized) {
46136 throw new Error("initializeWasm() must be awaited first!");
46138 const nativeResponseValue = wasm.TS_BlindedTail_set_blinding_point(this_ptr, val);
46139 // debug statements here
46141 // uint32_t BlindedTail_get_excess_final_cltv_expiry_delta(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
46143 export function BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr: bigint): number {
46144 if(!isWasmInitialized) {
46145 throw new Error("initializeWasm() must be awaited first!");
46147 const nativeResponseValue = wasm.TS_BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr);
46148 return nativeResponseValue;
46150 // void BlindedTail_set_excess_final_cltv_expiry_delta(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint32_t val);
46152 export function BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
46153 if(!isWasmInitialized) {
46154 throw new Error("initializeWasm() must be awaited first!");
46156 const nativeResponseValue = wasm.TS_BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr, val);
46157 // debug statements here
46159 // uint64_t BlindedTail_get_final_value_msat(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
46161 export function BlindedTail_get_final_value_msat(this_ptr: bigint): bigint {
46162 if(!isWasmInitialized) {
46163 throw new Error("initializeWasm() must be awaited first!");
46165 const nativeResponseValue = wasm.TS_BlindedTail_get_final_value_msat(this_ptr);
46166 return nativeResponseValue;
46168 // void BlindedTail_set_final_value_msat(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint64_t val);
46170 export function BlindedTail_set_final_value_msat(this_ptr: bigint, val: bigint): void {
46171 if(!isWasmInitialized) {
46172 throw new Error("initializeWasm() must be awaited first!");
46174 const nativeResponseValue = wasm.TS_BlindedTail_set_final_value_msat(this_ptr, val);
46175 // debug statements here
46177 // 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);
46179 export function BlindedTail_new(hops_arg: number, blinding_point_arg: number, excess_final_cltv_expiry_delta_arg: number, final_value_msat_arg: bigint): bigint {
46180 if(!isWasmInitialized) {
46181 throw new Error("initializeWasm() must be awaited first!");
46183 const nativeResponseValue = wasm.TS_BlindedTail_new(hops_arg, blinding_point_arg, excess_final_cltv_expiry_delta_arg, final_value_msat_arg);
46184 return nativeResponseValue;
46186 // uint64_t BlindedTail_clone_ptr(LDKBlindedTail *NONNULL_PTR arg);
46188 export function BlindedTail_clone_ptr(arg: bigint): bigint {
46189 if(!isWasmInitialized) {
46190 throw new Error("initializeWasm() must be awaited first!");
46192 const nativeResponseValue = wasm.TS_BlindedTail_clone_ptr(arg);
46193 return nativeResponseValue;
46195 // struct LDKBlindedTail BlindedTail_clone(const struct LDKBlindedTail *NONNULL_PTR orig);
46197 export function BlindedTail_clone(orig: bigint): bigint {
46198 if(!isWasmInitialized) {
46199 throw new Error("initializeWasm() must be awaited first!");
46201 const nativeResponseValue = wasm.TS_BlindedTail_clone(orig);
46202 return nativeResponseValue;
46204 // uint64_t BlindedTail_hash(const struct LDKBlindedTail *NONNULL_PTR o);
46206 export function BlindedTail_hash(o: bigint): bigint {
46207 if(!isWasmInitialized) {
46208 throw new Error("initializeWasm() must be awaited first!");
46210 const nativeResponseValue = wasm.TS_BlindedTail_hash(o);
46211 return nativeResponseValue;
46213 // bool BlindedTail_eq(const struct LDKBlindedTail *NONNULL_PTR a, const struct LDKBlindedTail *NONNULL_PTR b);
46215 export function BlindedTail_eq(a: bigint, b: bigint): boolean {
46216 if(!isWasmInitialized) {
46217 throw new Error("initializeWasm() must be awaited first!");
46219 const nativeResponseValue = wasm.TS_BlindedTail_eq(a, b);
46220 return nativeResponseValue;
46222 // struct LDKCVec_u8Z BlindedTail_write(const struct LDKBlindedTail *NONNULL_PTR obj);
46224 export function BlindedTail_write(obj: bigint): number {
46225 if(!isWasmInitialized) {
46226 throw new Error("initializeWasm() must be awaited first!");
46228 const nativeResponseValue = wasm.TS_BlindedTail_write(obj);
46229 return nativeResponseValue;
46231 // struct LDKCResult_BlindedTailDecodeErrorZ BlindedTail_read(struct LDKu8slice ser);
46233 export function BlindedTail_read(ser: number): bigint {
46234 if(!isWasmInitialized) {
46235 throw new Error("initializeWasm() must be awaited first!");
46237 const nativeResponseValue = wasm.TS_BlindedTail_read(ser);
46238 return nativeResponseValue;
46240 // void Path_free(struct LDKPath this_obj);
46242 export function Path_free(this_obj: bigint): void {
46243 if(!isWasmInitialized) {
46244 throw new Error("initializeWasm() must be awaited first!");
46246 const nativeResponseValue = wasm.TS_Path_free(this_obj);
46247 // debug statements here
46249 // struct LDKCVec_RouteHopZ Path_get_hops(const struct LDKPath *NONNULL_PTR this_ptr);
46251 export function Path_get_hops(this_ptr: bigint): number {
46252 if(!isWasmInitialized) {
46253 throw new Error("initializeWasm() must be awaited first!");
46255 const nativeResponseValue = wasm.TS_Path_get_hops(this_ptr);
46256 return nativeResponseValue;
46258 // void Path_set_hops(struct LDKPath *NONNULL_PTR this_ptr, struct LDKCVec_RouteHopZ val);
46260 export function Path_set_hops(this_ptr: bigint, val: number): void {
46261 if(!isWasmInitialized) {
46262 throw new Error("initializeWasm() must be awaited first!");
46264 const nativeResponseValue = wasm.TS_Path_set_hops(this_ptr, val);
46265 // debug statements here
46267 // struct LDKBlindedTail Path_get_blinded_tail(const struct LDKPath *NONNULL_PTR this_ptr);
46269 export function Path_get_blinded_tail(this_ptr: bigint): bigint {
46270 if(!isWasmInitialized) {
46271 throw new Error("initializeWasm() must be awaited first!");
46273 const nativeResponseValue = wasm.TS_Path_get_blinded_tail(this_ptr);
46274 return nativeResponseValue;
46276 // void Path_set_blinded_tail(struct LDKPath *NONNULL_PTR this_ptr, struct LDKBlindedTail val);
46278 export function Path_set_blinded_tail(this_ptr: bigint, val: bigint): void {
46279 if(!isWasmInitialized) {
46280 throw new Error("initializeWasm() must be awaited first!");
46282 const nativeResponseValue = wasm.TS_Path_set_blinded_tail(this_ptr, val);
46283 // debug statements here
46285 // MUST_USE_RES struct LDKPath Path_new(struct LDKCVec_RouteHopZ hops_arg, struct LDKBlindedTail blinded_tail_arg);
46287 export function Path_new(hops_arg: number, blinded_tail_arg: bigint): bigint {
46288 if(!isWasmInitialized) {
46289 throw new Error("initializeWasm() must be awaited first!");
46291 const nativeResponseValue = wasm.TS_Path_new(hops_arg, blinded_tail_arg);
46292 return nativeResponseValue;
46294 // uint64_t Path_clone_ptr(LDKPath *NONNULL_PTR arg);
46296 export function Path_clone_ptr(arg: bigint): bigint {
46297 if(!isWasmInitialized) {
46298 throw new Error("initializeWasm() must be awaited first!");
46300 const nativeResponseValue = wasm.TS_Path_clone_ptr(arg);
46301 return nativeResponseValue;
46303 // struct LDKPath Path_clone(const struct LDKPath *NONNULL_PTR orig);
46305 export function Path_clone(orig: bigint): bigint {
46306 if(!isWasmInitialized) {
46307 throw new Error("initializeWasm() must be awaited first!");
46309 const nativeResponseValue = wasm.TS_Path_clone(orig);
46310 return nativeResponseValue;
46312 // uint64_t Path_hash(const struct LDKPath *NONNULL_PTR o);
46314 export function Path_hash(o: bigint): bigint {
46315 if(!isWasmInitialized) {
46316 throw new Error("initializeWasm() must be awaited first!");
46318 const nativeResponseValue = wasm.TS_Path_hash(o);
46319 return nativeResponseValue;
46321 // bool Path_eq(const struct LDKPath *NONNULL_PTR a, const struct LDKPath *NONNULL_PTR b);
46323 export function Path_eq(a: bigint, b: bigint): boolean {
46324 if(!isWasmInitialized) {
46325 throw new Error("initializeWasm() must be awaited first!");
46327 const nativeResponseValue = wasm.TS_Path_eq(a, b);
46328 return nativeResponseValue;
46330 // MUST_USE_RES uint64_t Path_fee_msat(const struct LDKPath *NONNULL_PTR this_arg);
46332 export function Path_fee_msat(this_arg: bigint): bigint {
46333 if(!isWasmInitialized) {
46334 throw new Error("initializeWasm() must be awaited first!");
46336 const nativeResponseValue = wasm.TS_Path_fee_msat(this_arg);
46337 return nativeResponseValue;
46339 // MUST_USE_RES uint64_t Path_final_value_msat(const struct LDKPath *NONNULL_PTR this_arg);
46341 export function Path_final_value_msat(this_arg: bigint): bigint {
46342 if(!isWasmInitialized) {
46343 throw new Error("initializeWasm() must be awaited first!");
46345 const nativeResponseValue = wasm.TS_Path_final_value_msat(this_arg);
46346 return nativeResponseValue;
46348 // MUST_USE_RES struct LDKCOption_u32Z Path_final_cltv_expiry_delta(const struct LDKPath *NONNULL_PTR this_arg);
46350 export function Path_final_cltv_expiry_delta(this_arg: bigint): bigint {
46351 if(!isWasmInitialized) {
46352 throw new Error("initializeWasm() must be awaited first!");
46354 const nativeResponseValue = wasm.TS_Path_final_cltv_expiry_delta(this_arg);
46355 return nativeResponseValue;
46357 // void Route_free(struct LDKRoute this_obj);
46359 export function Route_free(this_obj: bigint): void {
46360 if(!isWasmInitialized) {
46361 throw new Error("initializeWasm() must be awaited first!");
46363 const nativeResponseValue = wasm.TS_Route_free(this_obj);
46364 // debug statements here
46366 // struct LDKCVec_PathZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
46368 export function Route_get_paths(this_ptr: bigint): number {
46369 if(!isWasmInitialized) {
46370 throw new Error("initializeWasm() must be awaited first!");
46372 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
46373 return nativeResponseValue;
46375 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_PathZ val);
46377 export function Route_set_paths(this_ptr: bigint, val: number): void {
46378 if(!isWasmInitialized) {
46379 throw new Error("initializeWasm() must be awaited first!");
46381 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
46382 // debug statements here
46384 // struct LDKRouteParameters Route_get_route_params(const struct LDKRoute *NONNULL_PTR this_ptr);
46386 export function Route_get_route_params(this_ptr: bigint): bigint {
46387 if(!isWasmInitialized) {
46388 throw new Error("initializeWasm() must be awaited first!");
46390 const nativeResponseValue = wasm.TS_Route_get_route_params(this_ptr);
46391 return nativeResponseValue;
46393 // void Route_set_route_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKRouteParameters val);
46395 export function Route_set_route_params(this_ptr: bigint, val: bigint): void {
46396 if(!isWasmInitialized) {
46397 throw new Error("initializeWasm() must be awaited first!");
46399 const nativeResponseValue = wasm.TS_Route_set_route_params(this_ptr, val);
46400 // debug statements here
46402 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_PathZ paths_arg, struct LDKRouteParameters route_params_arg);
46404 export function Route_new(paths_arg: number, route_params_arg: bigint): bigint {
46405 if(!isWasmInitialized) {
46406 throw new Error("initializeWasm() must be awaited first!");
46408 const nativeResponseValue = wasm.TS_Route_new(paths_arg, route_params_arg);
46409 return nativeResponseValue;
46411 // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
46413 export function Route_clone_ptr(arg: bigint): bigint {
46414 if(!isWasmInitialized) {
46415 throw new Error("initializeWasm() must be awaited first!");
46417 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
46418 return nativeResponseValue;
46420 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
46422 export function Route_clone(orig: bigint): bigint {
46423 if(!isWasmInitialized) {
46424 throw new Error("initializeWasm() must be awaited first!");
46426 const nativeResponseValue = wasm.TS_Route_clone(orig);
46427 return nativeResponseValue;
46429 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
46431 export function Route_hash(o: bigint): bigint {
46432 if(!isWasmInitialized) {
46433 throw new Error("initializeWasm() must be awaited first!");
46435 const nativeResponseValue = wasm.TS_Route_hash(o);
46436 return nativeResponseValue;
46438 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
46440 export function Route_eq(a: bigint, b: bigint): boolean {
46441 if(!isWasmInitialized) {
46442 throw new Error("initializeWasm() must be awaited first!");
46444 const nativeResponseValue = wasm.TS_Route_eq(a, b);
46445 return nativeResponseValue;
46447 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
46449 export function Route_get_total_fees(this_arg: bigint): bigint {
46450 if(!isWasmInitialized) {
46451 throw new Error("initializeWasm() must be awaited first!");
46453 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
46454 return nativeResponseValue;
46456 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
46458 export function Route_get_total_amount(this_arg: bigint): bigint {
46459 if(!isWasmInitialized) {
46460 throw new Error("initializeWasm() must be awaited first!");
46462 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
46463 return nativeResponseValue;
46465 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
46467 export function Route_write(obj: bigint): number {
46468 if(!isWasmInitialized) {
46469 throw new Error("initializeWasm() must be awaited first!");
46471 const nativeResponseValue = wasm.TS_Route_write(obj);
46472 return nativeResponseValue;
46474 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
46476 export function Route_read(ser: number): bigint {
46477 if(!isWasmInitialized) {
46478 throw new Error("initializeWasm() must be awaited first!");
46480 const nativeResponseValue = wasm.TS_Route_read(ser);
46481 return nativeResponseValue;
46483 // void RouteParameters_free(struct LDKRouteParameters this_obj);
46485 export function RouteParameters_free(this_obj: bigint): void {
46486 if(!isWasmInitialized) {
46487 throw new Error("initializeWasm() must be awaited first!");
46489 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
46490 // debug statements here
46492 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
46494 export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
46495 if(!isWasmInitialized) {
46496 throw new Error("initializeWasm() must be awaited first!");
46498 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
46499 return nativeResponseValue;
46501 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
46503 export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
46504 if(!isWasmInitialized) {
46505 throw new Error("initializeWasm() must be awaited first!");
46507 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
46508 // debug statements here
46510 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
46512 export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
46513 if(!isWasmInitialized) {
46514 throw new Error("initializeWasm() must be awaited first!");
46516 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
46517 return nativeResponseValue;
46519 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
46521 export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
46522 if(!isWasmInitialized) {
46523 throw new Error("initializeWasm() must be awaited first!");
46525 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
46526 // debug statements here
46528 // struct LDKCOption_u64Z RouteParameters_get_max_total_routing_fee_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
46530 export function RouteParameters_get_max_total_routing_fee_msat(this_ptr: bigint): bigint {
46531 if(!isWasmInitialized) {
46532 throw new Error("initializeWasm() must be awaited first!");
46534 const nativeResponseValue = wasm.TS_RouteParameters_get_max_total_routing_fee_msat(this_ptr);
46535 return nativeResponseValue;
46537 // void RouteParameters_set_max_total_routing_fee_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
46539 export function RouteParameters_set_max_total_routing_fee_msat(this_ptr: bigint, val: bigint): void {
46540 if(!isWasmInitialized) {
46541 throw new Error("initializeWasm() must be awaited first!");
46543 const nativeResponseValue = wasm.TS_RouteParameters_set_max_total_routing_fee_msat(this_ptr, val);
46544 // debug statements here
46546 // 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);
46548 export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint, max_total_routing_fee_msat_arg: bigint): bigint {
46549 if(!isWasmInitialized) {
46550 throw new Error("initializeWasm() must be awaited first!");
46552 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, max_total_routing_fee_msat_arg);
46553 return nativeResponseValue;
46555 // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
46557 export function RouteParameters_clone_ptr(arg: bigint): bigint {
46558 if(!isWasmInitialized) {
46559 throw new Error("initializeWasm() must be awaited first!");
46561 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
46562 return nativeResponseValue;
46564 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
46566 export function RouteParameters_clone(orig: bigint): bigint {
46567 if(!isWasmInitialized) {
46568 throw new Error("initializeWasm() must be awaited first!");
46570 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
46571 return nativeResponseValue;
46573 // uint64_t RouteParameters_hash(const struct LDKRouteParameters *NONNULL_PTR o);
46575 export function RouteParameters_hash(o: bigint): bigint {
46576 if(!isWasmInitialized) {
46577 throw new Error("initializeWasm() must be awaited first!");
46579 const nativeResponseValue = wasm.TS_RouteParameters_hash(o);
46580 return nativeResponseValue;
46582 // bool RouteParameters_eq(const struct LDKRouteParameters *NONNULL_PTR a, const struct LDKRouteParameters *NONNULL_PTR b);
46584 export function RouteParameters_eq(a: bigint, b: bigint): boolean {
46585 if(!isWasmInitialized) {
46586 throw new Error("initializeWasm() must be awaited first!");
46588 const nativeResponseValue = wasm.TS_RouteParameters_eq(a, b);
46589 return nativeResponseValue;
46591 // MUST_USE_RES struct LDKRouteParameters RouteParameters_from_payment_params_and_value(struct LDKPaymentParameters payment_params, uint64_t final_value_msat);
46593 export function RouteParameters_from_payment_params_and_value(payment_params: bigint, final_value_msat: bigint): bigint {
46594 if(!isWasmInitialized) {
46595 throw new Error("initializeWasm() must be awaited first!");
46597 const nativeResponseValue = wasm.TS_RouteParameters_from_payment_params_and_value(payment_params, final_value_msat);
46598 return nativeResponseValue;
46600 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
46602 export function RouteParameters_write(obj: bigint): number {
46603 if(!isWasmInitialized) {
46604 throw new Error("initializeWasm() must be awaited first!");
46606 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
46607 return nativeResponseValue;
46609 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
46611 export function RouteParameters_read(ser: number): bigint {
46612 if(!isWasmInitialized) {
46613 throw new Error("initializeWasm() must be awaited first!");
46615 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
46616 return nativeResponseValue;
46618 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
46620 export function PaymentParameters_free(this_obj: bigint): void {
46621 if(!isWasmInitialized) {
46622 throw new Error("initializeWasm() must be awaited first!");
46624 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
46625 // debug statements here
46627 // struct LDKPayee PaymentParameters_get_payee(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46629 export function PaymentParameters_get_payee(this_ptr: bigint): bigint {
46630 if(!isWasmInitialized) {
46631 throw new Error("initializeWasm() must be awaited first!");
46633 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee(this_ptr);
46634 return nativeResponseValue;
46636 // void PaymentParameters_set_payee(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPayee val);
46638 export function PaymentParameters_set_payee(this_ptr: bigint, val: bigint): void {
46639 if(!isWasmInitialized) {
46640 throw new Error("initializeWasm() must be awaited first!");
46642 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee(this_ptr, val);
46643 // debug statements here
46645 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46647 export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
46648 if(!isWasmInitialized) {
46649 throw new Error("initializeWasm() must be awaited first!");
46651 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
46652 return nativeResponseValue;
46654 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
46656 export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
46657 if(!isWasmInitialized) {
46658 throw new Error("initializeWasm() must be awaited first!");
46660 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
46661 // debug statements here
46663 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46665 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
46666 if(!isWasmInitialized) {
46667 throw new Error("initializeWasm() must be awaited first!");
46669 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
46670 return nativeResponseValue;
46672 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
46674 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
46675 if(!isWasmInitialized) {
46676 throw new Error("initializeWasm() must be awaited first!");
46678 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
46679 // debug statements here
46681 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46683 export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
46684 if(!isWasmInitialized) {
46685 throw new Error("initializeWasm() must be awaited first!");
46687 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
46688 return nativeResponseValue;
46690 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
46692 export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
46693 if(!isWasmInitialized) {
46694 throw new Error("initializeWasm() must be awaited first!");
46696 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
46697 // debug statements here
46699 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46701 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
46702 if(!isWasmInitialized) {
46703 throw new Error("initializeWasm() must be awaited first!");
46705 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
46706 return nativeResponseValue;
46708 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
46710 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
46711 if(!isWasmInitialized) {
46712 throw new Error("initializeWasm() must be awaited first!");
46714 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
46715 // debug statements here
46717 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
46719 export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
46720 if(!isWasmInitialized) {
46721 throw new Error("initializeWasm() must be awaited first!");
46723 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
46724 return nativeResponseValue;
46726 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
46728 export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
46729 if(!isWasmInitialized) {
46730 throw new Error("initializeWasm() must be awaited first!");
46732 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
46733 // debug statements here
46735 // 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);
46737 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): bigint {
46738 if(!isWasmInitialized) {
46739 throw new Error("initializeWasm() must be awaited first!");
46741 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);
46742 return nativeResponseValue;
46744 // uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
46746 export function PaymentParameters_clone_ptr(arg: bigint): bigint {
46747 if(!isWasmInitialized) {
46748 throw new Error("initializeWasm() must be awaited first!");
46750 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
46751 return nativeResponseValue;
46753 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
46755 export function PaymentParameters_clone(orig: bigint): bigint {
46756 if(!isWasmInitialized) {
46757 throw new Error("initializeWasm() must be awaited first!");
46759 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
46760 return nativeResponseValue;
46762 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
46764 export function PaymentParameters_hash(o: bigint): bigint {
46765 if(!isWasmInitialized) {
46766 throw new Error("initializeWasm() must be awaited first!");
46768 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
46769 return nativeResponseValue;
46771 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
46773 export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
46774 if(!isWasmInitialized) {
46775 throw new Error("initializeWasm() must be awaited first!");
46777 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
46778 return nativeResponseValue;
46780 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
46782 export function PaymentParameters_write(obj: bigint): number {
46783 if(!isWasmInitialized) {
46784 throw new Error("initializeWasm() must be awaited first!");
46786 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
46787 return nativeResponseValue;
46789 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser, uint32_t arg);
46791 export function PaymentParameters_read(ser: number, arg: number): bigint {
46792 if(!isWasmInitialized) {
46793 throw new Error("initializeWasm() must be awaited first!");
46795 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser, arg);
46796 return nativeResponseValue;
46798 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta);
46800 export function PaymentParameters_from_node_id(payee_pubkey: number, final_cltv_expiry_delta: number): bigint {
46801 if(!isWasmInitialized) {
46802 throw new Error("initializeWasm() must be awaited first!");
46804 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey, final_cltv_expiry_delta);
46805 return nativeResponseValue;
46807 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta, bool allow_mpp);
46809 export function PaymentParameters_for_keysend(payee_pubkey: number, final_cltv_expiry_delta: number, allow_mpp: boolean): bigint {
46810 if(!isWasmInitialized) {
46811 throw new Error("initializeWasm() must be awaited first!");
46813 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey, final_cltv_expiry_delta, allow_mpp);
46814 return nativeResponseValue;
46816 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_bolt12_invoice(const struct LDKBolt12Invoice *NONNULL_PTR invoice);
46818 export function PaymentParameters_from_bolt12_invoice(invoice: bigint): bigint {
46819 if(!isWasmInitialized) {
46820 throw new Error("initializeWasm() must be awaited first!");
46822 const nativeResponseValue = wasm.TS_PaymentParameters_from_bolt12_invoice(invoice);
46823 return nativeResponseValue;
46825 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_blinded(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ blinded_route_hints);
46827 export function PaymentParameters_blinded(blinded_route_hints: number): bigint {
46828 if(!isWasmInitialized) {
46829 throw new Error("initializeWasm() must be awaited first!");
46831 const nativeResponseValue = wasm.TS_PaymentParameters_blinded(blinded_route_hints);
46832 return nativeResponseValue;
46834 // void Payee_free(struct LDKPayee this_ptr);
46836 export function Payee_free(this_ptr: bigint): void {
46837 if(!isWasmInitialized) {
46838 throw new Error("initializeWasm() must be awaited first!");
46840 const nativeResponseValue = wasm.TS_Payee_free(this_ptr);
46841 // debug statements here
46843 // uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg);
46845 export function Payee_clone_ptr(arg: bigint): bigint {
46846 if(!isWasmInitialized) {
46847 throw new Error("initializeWasm() must be awaited first!");
46849 const nativeResponseValue = wasm.TS_Payee_clone_ptr(arg);
46850 return nativeResponseValue;
46852 // struct LDKPayee Payee_clone(const struct LDKPayee *NONNULL_PTR orig);
46854 export function Payee_clone(orig: bigint): bigint {
46855 if(!isWasmInitialized) {
46856 throw new Error("initializeWasm() must be awaited first!");
46858 const nativeResponseValue = wasm.TS_Payee_clone(orig);
46859 return nativeResponseValue;
46861 // struct LDKPayee Payee_blinded(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ route_hints, struct LDKBolt12InvoiceFeatures features);
46863 export function Payee_blinded(route_hints: number, features: bigint): bigint {
46864 if(!isWasmInitialized) {
46865 throw new Error("initializeWasm() must be awaited first!");
46867 const nativeResponseValue = wasm.TS_Payee_blinded(route_hints, features);
46868 return nativeResponseValue;
46870 // struct LDKPayee Payee_clear(struct LDKPublicKey node_id, struct LDKCVec_RouteHintZ route_hints, struct LDKBolt11InvoiceFeatures features, uint32_t final_cltv_expiry_delta);
46872 export function Payee_clear(node_id: number, route_hints: number, features: bigint, final_cltv_expiry_delta: number): bigint {
46873 if(!isWasmInitialized) {
46874 throw new Error("initializeWasm() must be awaited first!");
46876 const nativeResponseValue = wasm.TS_Payee_clear(node_id, route_hints, features, final_cltv_expiry_delta);
46877 return nativeResponseValue;
46879 // uint64_t Payee_hash(const struct LDKPayee *NONNULL_PTR o);
46881 export function Payee_hash(o: bigint): bigint {
46882 if(!isWasmInitialized) {
46883 throw new Error("initializeWasm() must be awaited first!");
46885 const nativeResponseValue = wasm.TS_Payee_hash(o);
46886 return nativeResponseValue;
46888 // bool Payee_eq(const struct LDKPayee *NONNULL_PTR a, const struct LDKPayee *NONNULL_PTR b);
46890 export function Payee_eq(a: bigint, b: bigint): boolean {
46891 if(!isWasmInitialized) {
46892 throw new Error("initializeWasm() must be awaited first!");
46894 const nativeResponseValue = wasm.TS_Payee_eq(a, b);
46895 return nativeResponseValue;
46897 // void RouteHint_free(struct LDKRouteHint this_obj);
46899 export function RouteHint_free(this_obj: bigint): void {
46900 if(!isWasmInitialized) {
46901 throw new Error("initializeWasm() must be awaited first!");
46903 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
46904 // debug statements here
46906 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
46908 export function RouteHint_get_a(this_ptr: bigint): number {
46909 if(!isWasmInitialized) {
46910 throw new Error("initializeWasm() must be awaited first!");
46912 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
46913 return nativeResponseValue;
46915 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
46917 export function RouteHint_set_a(this_ptr: bigint, val: number): void {
46918 if(!isWasmInitialized) {
46919 throw new Error("initializeWasm() must be awaited first!");
46921 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
46922 // debug statements here
46924 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
46926 export function RouteHint_new(a_arg: number): bigint {
46927 if(!isWasmInitialized) {
46928 throw new Error("initializeWasm() must be awaited first!");
46930 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
46931 return nativeResponseValue;
46933 // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
46935 export function RouteHint_clone_ptr(arg: bigint): bigint {
46936 if(!isWasmInitialized) {
46937 throw new Error("initializeWasm() must be awaited first!");
46939 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
46940 return nativeResponseValue;
46942 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
46944 export function RouteHint_clone(orig: bigint): bigint {
46945 if(!isWasmInitialized) {
46946 throw new Error("initializeWasm() must be awaited first!");
46948 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
46949 return nativeResponseValue;
46951 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
46953 export function RouteHint_hash(o: bigint): bigint {
46954 if(!isWasmInitialized) {
46955 throw new Error("initializeWasm() must be awaited first!");
46957 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
46958 return nativeResponseValue;
46960 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
46962 export function RouteHint_eq(a: bigint, b: bigint): boolean {
46963 if(!isWasmInitialized) {
46964 throw new Error("initializeWasm() must be awaited first!");
46966 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
46967 return nativeResponseValue;
46969 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
46971 export function RouteHint_write(obj: bigint): number {
46972 if(!isWasmInitialized) {
46973 throw new Error("initializeWasm() must be awaited first!");
46975 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
46976 return nativeResponseValue;
46978 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
46980 export function RouteHint_read(ser: number): bigint {
46981 if(!isWasmInitialized) {
46982 throw new Error("initializeWasm() must be awaited first!");
46984 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
46985 return nativeResponseValue;
46987 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
46989 export function RouteHintHop_free(this_obj: bigint): void {
46990 if(!isWasmInitialized) {
46991 throw new Error("initializeWasm() must be awaited first!");
46993 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
46994 // debug statements here
46996 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
46998 export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
46999 if(!isWasmInitialized) {
47000 throw new Error("initializeWasm() must be awaited first!");
47002 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
47003 return nativeResponseValue;
47005 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
47007 export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
47008 if(!isWasmInitialized) {
47009 throw new Error("initializeWasm() must be awaited first!");
47011 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
47012 // debug statements here
47014 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
47016 export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
47017 if(!isWasmInitialized) {
47018 throw new Error("initializeWasm() must be awaited first!");
47020 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
47021 return nativeResponseValue;
47023 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
47025 export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
47026 if(!isWasmInitialized) {
47027 throw new Error("initializeWasm() must be awaited first!");
47029 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
47030 // debug statements here
47032 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
47034 export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
47035 if(!isWasmInitialized) {
47036 throw new Error("initializeWasm() must be awaited first!");
47038 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
47039 return nativeResponseValue;
47041 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
47043 export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
47044 if(!isWasmInitialized) {
47045 throw new Error("initializeWasm() must be awaited first!");
47047 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
47048 // debug statements here
47050 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
47052 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
47053 if(!isWasmInitialized) {
47054 throw new Error("initializeWasm() must be awaited first!");
47056 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
47057 return nativeResponseValue;
47059 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
47061 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
47062 if(!isWasmInitialized) {
47063 throw new Error("initializeWasm() must be awaited first!");
47065 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
47066 // debug statements here
47068 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
47070 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
47071 if(!isWasmInitialized) {
47072 throw new Error("initializeWasm() must be awaited first!");
47074 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
47075 return nativeResponseValue;
47077 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
47079 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
47080 if(!isWasmInitialized) {
47081 throw new Error("initializeWasm() must be awaited first!");
47083 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
47084 // debug statements here
47086 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
47088 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
47089 if(!isWasmInitialized) {
47090 throw new Error("initializeWasm() must be awaited first!");
47092 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
47093 return nativeResponseValue;
47095 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
47097 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
47098 if(!isWasmInitialized) {
47099 throw new Error("initializeWasm() must be awaited first!");
47101 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
47102 // debug statements here
47104 // 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);
47106 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 {
47107 if(!isWasmInitialized) {
47108 throw new Error("initializeWasm() must be awaited first!");
47110 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);
47111 return nativeResponseValue;
47113 // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
47115 export function RouteHintHop_clone_ptr(arg: bigint): bigint {
47116 if(!isWasmInitialized) {
47117 throw new Error("initializeWasm() must be awaited first!");
47119 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
47120 return nativeResponseValue;
47122 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
47124 export function RouteHintHop_clone(orig: bigint): bigint {
47125 if(!isWasmInitialized) {
47126 throw new Error("initializeWasm() must be awaited first!");
47128 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
47129 return nativeResponseValue;
47131 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
47133 export function RouteHintHop_hash(o: bigint): bigint {
47134 if(!isWasmInitialized) {
47135 throw new Error("initializeWasm() must be awaited first!");
47137 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
47138 return nativeResponseValue;
47140 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
47142 export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
47143 if(!isWasmInitialized) {
47144 throw new Error("initializeWasm() must be awaited first!");
47146 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
47147 return nativeResponseValue;
47149 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
47151 export function RouteHintHop_write(obj: bigint): number {
47152 if(!isWasmInitialized) {
47153 throw new Error("initializeWasm() must be awaited first!");
47155 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
47156 return nativeResponseValue;
47158 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
47160 export function RouteHintHop_read(ser: number): bigint {
47161 if(!isWasmInitialized) {
47162 throw new Error("initializeWasm() must be awaited first!");
47164 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
47165 return nativeResponseValue;
47167 // 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]);
47169 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 {
47170 if(!isWasmInitialized) {
47171 throw new Error("initializeWasm() must be awaited first!");
47173 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, score_params, random_seed_bytes);
47174 return nativeResponseValue;
47176 // 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]);
47178 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 {
47179 if(!isWasmInitialized) {
47180 throw new Error("initializeWasm() must be awaited first!");
47182 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
47183 return nativeResponseValue;
47185 // void ScoreLookUp_free(struct LDKScoreLookUp this_ptr);
47187 export function ScoreLookUp_free(this_ptr: bigint): void {
47188 if(!isWasmInitialized) {
47189 throw new Error("initializeWasm() must be awaited first!");
47191 const nativeResponseValue = wasm.TS_ScoreLookUp_free(this_ptr);
47192 // debug statements here
47194 // void ScoreUpdate_free(struct LDKScoreUpdate this_ptr);
47196 export function ScoreUpdate_free(this_ptr: bigint): void {
47197 if(!isWasmInitialized) {
47198 throw new Error("initializeWasm() must be awaited first!");
47200 const nativeResponseValue = wasm.TS_ScoreUpdate_free(this_ptr);
47201 // debug statements here
47203 // void Score_free(struct LDKScore this_ptr);
47205 export function Score_free(this_ptr: bigint): void {
47206 if(!isWasmInitialized) {
47207 throw new Error("initializeWasm() must be awaited first!");
47209 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
47210 // debug statements here
47212 // void LockableScore_free(struct LDKLockableScore this_ptr);
47214 export function LockableScore_free(this_ptr: bigint): void {
47215 if(!isWasmInitialized) {
47216 throw new Error("initializeWasm() must be awaited first!");
47218 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
47219 // debug statements here
47221 // void WriteableScore_free(struct LDKWriteableScore this_ptr);
47223 export function WriteableScore_free(this_ptr: bigint): void {
47224 if(!isWasmInitialized) {
47225 throw new Error("initializeWasm() must be awaited first!");
47227 const nativeResponseValue = wasm.TS_WriteableScore_free(this_ptr);
47228 // debug statements here
47230 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
47232 export function MultiThreadedLockableScore_free(this_obj: bigint): void {
47233 if(!isWasmInitialized) {
47234 throw new Error("initializeWasm() must be awaited first!");
47236 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
47237 // debug statements here
47239 // struct LDKLockableScore MultiThreadedLockableScore_as_LockableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
47241 export function MultiThreadedLockableScore_as_LockableScore(this_arg: bigint): bigint {
47242 if(!isWasmInitialized) {
47243 throw new Error("initializeWasm() must be awaited first!");
47245 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_LockableScore(this_arg);
47246 return nativeResponseValue;
47248 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
47250 export function MultiThreadedLockableScore_write(obj: bigint): number {
47251 if(!isWasmInitialized) {
47252 throw new Error("initializeWasm() must be awaited first!");
47254 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
47255 return nativeResponseValue;
47257 // struct LDKWriteableScore MultiThreadedLockableScore_as_WriteableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
47259 export function MultiThreadedLockableScore_as_WriteableScore(this_arg: bigint): bigint {
47260 if(!isWasmInitialized) {
47261 throw new Error("initializeWasm() must be awaited first!");
47263 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_WriteableScore(this_arg);
47264 return nativeResponseValue;
47266 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
47268 export function MultiThreadedLockableScore_new(score: bigint): bigint {
47269 if(!isWasmInitialized) {
47270 throw new Error("initializeWasm() must be awaited first!");
47272 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
47273 return nativeResponseValue;
47275 // void MultiThreadedScoreLockRead_free(struct LDKMultiThreadedScoreLockRead this_obj);
47277 export function MultiThreadedScoreLockRead_free(this_obj: bigint): void {
47278 if(!isWasmInitialized) {
47279 throw new Error("initializeWasm() must be awaited first!");
47281 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockRead_free(this_obj);
47282 // debug statements here
47284 // void MultiThreadedScoreLockWrite_free(struct LDKMultiThreadedScoreLockWrite this_obj);
47286 export function MultiThreadedScoreLockWrite_free(this_obj: bigint): void {
47287 if(!isWasmInitialized) {
47288 throw new Error("initializeWasm() must be awaited first!");
47290 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_free(this_obj);
47291 // debug statements here
47293 // struct LDKScoreLookUp MultiThreadedScoreLockRead_as_ScoreLookUp(const struct LDKMultiThreadedScoreLockRead *NONNULL_PTR this_arg);
47295 export function MultiThreadedScoreLockRead_as_ScoreLookUp(this_arg: bigint): bigint {
47296 if(!isWasmInitialized) {
47297 throw new Error("initializeWasm() must be awaited first!");
47299 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockRead_as_ScoreLookUp(this_arg);
47300 return nativeResponseValue;
47302 // struct LDKCVec_u8Z MultiThreadedScoreLockWrite_write(const struct LDKMultiThreadedScoreLockWrite *NONNULL_PTR obj);
47304 export function MultiThreadedScoreLockWrite_write(obj: bigint): number {
47305 if(!isWasmInitialized) {
47306 throw new Error("initializeWasm() must be awaited first!");
47308 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_write(obj);
47309 return nativeResponseValue;
47311 // struct LDKScoreUpdate MultiThreadedScoreLockWrite_as_ScoreUpdate(const struct LDKMultiThreadedScoreLockWrite *NONNULL_PTR this_arg);
47313 export function MultiThreadedScoreLockWrite_as_ScoreUpdate(this_arg: bigint): bigint {
47314 if(!isWasmInitialized) {
47315 throw new Error("initializeWasm() must be awaited first!");
47317 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_as_ScoreUpdate(this_arg);
47318 return nativeResponseValue;
47320 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
47322 export function ChannelUsage_free(this_obj: bigint): void {
47323 if(!isWasmInitialized) {
47324 throw new Error("initializeWasm() must be awaited first!");
47326 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
47327 // debug statements here
47329 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
47331 export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
47332 if(!isWasmInitialized) {
47333 throw new Error("initializeWasm() must be awaited first!");
47335 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
47336 return nativeResponseValue;
47338 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
47340 export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
47341 if(!isWasmInitialized) {
47342 throw new Error("initializeWasm() must be awaited first!");
47344 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
47345 // debug statements here
47347 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
47349 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
47350 if(!isWasmInitialized) {
47351 throw new Error("initializeWasm() must be awaited first!");
47353 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
47354 return nativeResponseValue;
47356 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
47358 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
47359 if(!isWasmInitialized) {
47360 throw new Error("initializeWasm() must be awaited first!");
47362 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
47363 // debug statements here
47365 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
47367 export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
47368 if(!isWasmInitialized) {
47369 throw new Error("initializeWasm() must be awaited first!");
47371 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
47372 return nativeResponseValue;
47374 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
47376 export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
47377 if(!isWasmInitialized) {
47378 throw new Error("initializeWasm() must be awaited first!");
47380 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
47381 // debug statements here
47383 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
47385 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
47386 if(!isWasmInitialized) {
47387 throw new Error("initializeWasm() must be awaited first!");
47389 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
47390 return nativeResponseValue;
47392 // uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
47394 export function ChannelUsage_clone_ptr(arg: bigint): bigint {
47395 if(!isWasmInitialized) {
47396 throw new Error("initializeWasm() must be awaited first!");
47398 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
47399 return nativeResponseValue;
47401 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
47403 export function ChannelUsage_clone(orig: bigint): bigint {
47404 if(!isWasmInitialized) {
47405 throw new Error("initializeWasm() must be awaited first!");
47407 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
47408 return nativeResponseValue;
47410 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
47412 export function FixedPenaltyScorer_free(this_obj: bigint): void {
47413 if(!isWasmInitialized) {
47414 throw new Error("initializeWasm() must be awaited first!");
47416 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
47417 // debug statements here
47419 // uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
47421 export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
47422 if(!isWasmInitialized) {
47423 throw new Error("initializeWasm() must be awaited first!");
47425 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
47426 return nativeResponseValue;
47428 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
47430 export function FixedPenaltyScorer_clone(orig: bigint): bigint {
47431 if(!isWasmInitialized) {
47432 throw new Error("initializeWasm() must be awaited first!");
47434 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
47435 return nativeResponseValue;
47437 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
47439 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
47440 if(!isWasmInitialized) {
47441 throw new Error("initializeWasm() must be awaited first!");
47443 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
47444 return nativeResponseValue;
47446 // struct LDKScoreLookUp FixedPenaltyScorer_as_ScoreLookUp(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
47448 export function FixedPenaltyScorer_as_ScoreLookUp(this_arg: bigint): bigint {
47449 if(!isWasmInitialized) {
47450 throw new Error("initializeWasm() must be awaited first!");
47452 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_ScoreLookUp(this_arg);
47453 return nativeResponseValue;
47455 // struct LDKScoreUpdate FixedPenaltyScorer_as_ScoreUpdate(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
47457 export function FixedPenaltyScorer_as_ScoreUpdate(this_arg: bigint): bigint {
47458 if(!isWasmInitialized) {
47459 throw new Error("initializeWasm() must be awaited first!");
47461 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_ScoreUpdate(this_arg);
47462 return nativeResponseValue;
47464 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
47466 export function FixedPenaltyScorer_write(obj: bigint): number {
47467 if(!isWasmInitialized) {
47468 throw new Error("initializeWasm() must be awaited first!");
47470 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
47471 return nativeResponseValue;
47473 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
47475 export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
47476 if(!isWasmInitialized) {
47477 throw new Error("initializeWasm() must be awaited first!");
47479 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
47480 return nativeResponseValue;
47482 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
47484 export function ProbabilisticScorer_free(this_obj: bigint): void {
47485 if(!isWasmInitialized) {
47486 throw new Error("initializeWasm() must be awaited first!");
47488 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
47489 // debug statements here
47491 // void ProbabilisticScoringFeeParameters_free(struct LDKProbabilisticScoringFeeParameters this_obj);
47493 export function ProbabilisticScoringFeeParameters_free(this_obj: bigint): void {
47494 if(!isWasmInitialized) {
47495 throw new Error("initializeWasm() must be awaited first!");
47497 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_free(this_obj);
47498 // debug statements here
47500 // uint64_t ProbabilisticScoringFeeParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47502 export function ProbabilisticScoringFeeParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
47503 if(!isWasmInitialized) {
47504 throw new Error("initializeWasm() must be awaited first!");
47506 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_base_penalty_msat(this_ptr);
47507 return nativeResponseValue;
47509 // void ProbabilisticScoringFeeParameters_set_base_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47511 export function ProbabilisticScoringFeeParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
47512 if(!isWasmInitialized) {
47513 throw new Error("initializeWasm() must be awaited first!");
47515 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_base_penalty_msat(this_ptr, val);
47516 // debug statements here
47518 // uint64_t ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47520 export function ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
47521 if(!isWasmInitialized) {
47522 throw new Error("initializeWasm() must be awaited first!");
47524 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
47525 return nativeResponseValue;
47527 // void ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47529 export function ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
47530 if(!isWasmInitialized) {
47531 throw new Error("initializeWasm() must be awaited first!");
47533 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
47534 // debug statements here
47536 // uint64_t ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47538 export function ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
47539 if(!isWasmInitialized) {
47540 throw new Error("initializeWasm() must be awaited first!");
47542 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
47543 return nativeResponseValue;
47545 // void ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47547 export function ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
47548 if(!isWasmInitialized) {
47549 throw new Error("initializeWasm() must be awaited first!");
47551 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
47552 // debug statements here
47554 // uint64_t ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47556 export function ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
47557 if(!isWasmInitialized) {
47558 throw new Error("initializeWasm() must be awaited first!");
47560 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
47561 return nativeResponseValue;
47563 // void ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47565 export function ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
47566 if(!isWasmInitialized) {
47567 throw new Error("initializeWasm() must be awaited first!");
47569 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
47570 // debug statements here
47572 // uint64_t ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47574 export function ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
47575 if(!isWasmInitialized) {
47576 throw new Error("initializeWasm() must be awaited first!");
47578 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr);
47579 return nativeResponseValue;
47581 // void ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47583 export function ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
47584 if(!isWasmInitialized) {
47585 throw new Error("initializeWasm() must be awaited first!");
47587 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr, val);
47588 // debug statements here
47590 // uint64_t ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47592 export function ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
47593 if(!isWasmInitialized) {
47594 throw new Error("initializeWasm() must be awaited first!");
47596 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr);
47597 return nativeResponseValue;
47599 // void ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47601 export function ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
47602 if(!isWasmInitialized) {
47603 throw new Error("initializeWasm() must be awaited first!");
47605 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
47606 // debug statements here
47608 // uint64_t ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47610 export function ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
47611 if(!isWasmInitialized) {
47612 throw new Error("initializeWasm() must be awaited first!");
47614 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(this_ptr);
47615 return nativeResponseValue;
47617 // void ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47619 export function ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
47620 if(!isWasmInitialized) {
47621 throw new Error("initializeWasm() must be awaited first!");
47623 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(this_ptr, val);
47624 // debug statements here
47626 // uint64_t ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47628 export function ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
47629 if(!isWasmInitialized) {
47630 throw new Error("initializeWasm() must be awaited first!");
47632 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(this_ptr);
47633 return nativeResponseValue;
47635 // void ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
47637 export function ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
47638 if(!isWasmInitialized) {
47639 throw new Error("initializeWasm() must be awaited first!");
47641 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(this_ptr, val);
47642 // debug statements here
47644 // bool ProbabilisticScoringFeeParameters_get_linear_success_probability(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
47646 export function ProbabilisticScoringFeeParameters_get_linear_success_probability(this_ptr: bigint): boolean {
47647 if(!isWasmInitialized) {
47648 throw new Error("initializeWasm() must be awaited first!");
47650 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_linear_success_probability(this_ptr);
47651 return nativeResponseValue;
47653 // void ProbabilisticScoringFeeParameters_set_linear_success_probability(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, bool val);
47655 export function ProbabilisticScoringFeeParameters_set_linear_success_probability(this_ptr: bigint, val: boolean): void {
47656 if(!isWasmInitialized) {
47657 throw new Error("initializeWasm() must be awaited first!");
47659 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_linear_success_probability(this_ptr, val);
47660 // debug statements here
47662 // uint64_t ProbabilisticScoringFeeParameters_clone_ptr(LDKProbabilisticScoringFeeParameters *NONNULL_PTR arg);
47664 export function ProbabilisticScoringFeeParameters_clone_ptr(arg: bigint): bigint {
47665 if(!isWasmInitialized) {
47666 throw new Error("initializeWasm() must be awaited first!");
47668 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clone_ptr(arg);
47669 return nativeResponseValue;
47671 // struct LDKProbabilisticScoringFeeParameters ProbabilisticScoringFeeParameters_clone(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR orig);
47673 export function ProbabilisticScoringFeeParameters_clone(orig: bigint): bigint {
47674 if(!isWasmInitialized) {
47675 throw new Error("initializeWasm() must be awaited first!");
47677 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clone(orig);
47678 return nativeResponseValue;
47680 // MUST_USE_RES struct LDKProbabilisticScoringFeeParameters ProbabilisticScoringFeeParameters_default(void);
47682 export function ProbabilisticScoringFeeParameters_default(): bigint {
47683 if(!isWasmInitialized) {
47684 throw new Error("initializeWasm() must be awaited first!");
47686 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_default();
47687 return nativeResponseValue;
47689 // void ProbabilisticScoringFeeParameters_add_banned(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
47691 export function ProbabilisticScoringFeeParameters_add_banned(this_arg: bigint, node_id: bigint): void {
47692 if(!isWasmInitialized) {
47693 throw new Error("initializeWasm() must be awaited first!");
47695 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_add_banned(this_arg, node_id);
47696 // debug statements here
47698 // void ProbabilisticScoringFeeParameters_add_banned_from_list(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
47700 export function ProbabilisticScoringFeeParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
47701 if(!isWasmInitialized) {
47702 throw new Error("initializeWasm() must be awaited first!");
47704 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_add_banned_from_list(this_arg, node_ids);
47705 // debug statements here
47707 // void ProbabilisticScoringFeeParameters_remove_banned(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
47709 export function ProbabilisticScoringFeeParameters_remove_banned(this_arg: bigint, node_id: bigint): void {
47710 if(!isWasmInitialized) {
47711 throw new Error("initializeWasm() must be awaited first!");
47713 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_remove_banned(this_arg, node_id);
47714 // debug statements here
47716 // void ProbabilisticScoringFeeParameters_set_manual_penalty(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
47718 export function ProbabilisticScoringFeeParameters_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
47719 if(!isWasmInitialized) {
47720 throw new Error("initializeWasm() must be awaited first!");
47722 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_manual_penalty(this_arg, node_id, penalty);
47723 // debug statements here
47725 // void ProbabilisticScoringFeeParameters_remove_manual_penalty(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
47727 export function ProbabilisticScoringFeeParameters_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
47728 if(!isWasmInitialized) {
47729 throw new Error("initializeWasm() must be awaited first!");
47731 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_remove_manual_penalty(this_arg, node_id);
47732 // debug statements here
47734 // void ProbabilisticScoringFeeParameters_clear_manual_penalties(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg);
47736 export function ProbabilisticScoringFeeParameters_clear_manual_penalties(this_arg: bigint): void {
47737 if(!isWasmInitialized) {
47738 throw new Error("initializeWasm() must be awaited first!");
47740 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clear_manual_penalties(this_arg);
47741 // debug statements here
47743 // void ProbabilisticScoringDecayParameters_free(struct LDKProbabilisticScoringDecayParameters this_obj);
47745 export function ProbabilisticScoringDecayParameters_free(this_obj: bigint): void {
47746 if(!isWasmInitialized) {
47747 throw new Error("initializeWasm() must be awaited first!");
47749 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_free(this_obj);
47750 // debug statements here
47752 // uint64_t ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr);
47754 export function ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(this_ptr: bigint): bigint {
47755 if(!isWasmInitialized) {
47756 throw new Error("initializeWasm() must be awaited first!");
47758 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(this_ptr);
47759 return nativeResponseValue;
47761 // void ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr, uint64_t val);
47763 export function ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(this_ptr: bigint, val: bigint): void {
47764 if(!isWasmInitialized) {
47765 throw new Error("initializeWasm() must be awaited first!");
47767 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(this_ptr, val);
47768 // debug statements here
47770 // uint64_t ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr);
47772 export function ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
47773 if(!isWasmInitialized) {
47774 throw new Error("initializeWasm() must be awaited first!");
47776 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(this_ptr);
47777 return nativeResponseValue;
47779 // void ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr, uint64_t val);
47781 export function ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
47782 if(!isWasmInitialized) {
47783 throw new Error("initializeWasm() must be awaited first!");
47785 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(this_ptr, val);
47786 // debug statements here
47788 // MUST_USE_RES struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_new(uint64_t historical_no_updates_half_life_arg, uint64_t liquidity_offset_half_life_arg);
47790 export function ProbabilisticScoringDecayParameters_new(historical_no_updates_half_life_arg: bigint, liquidity_offset_half_life_arg: bigint): bigint {
47791 if(!isWasmInitialized) {
47792 throw new Error("initializeWasm() must be awaited first!");
47794 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_new(historical_no_updates_half_life_arg, liquidity_offset_half_life_arg);
47795 return nativeResponseValue;
47797 // uint64_t ProbabilisticScoringDecayParameters_clone_ptr(LDKProbabilisticScoringDecayParameters *NONNULL_PTR arg);
47799 export function ProbabilisticScoringDecayParameters_clone_ptr(arg: bigint): bigint {
47800 if(!isWasmInitialized) {
47801 throw new Error("initializeWasm() must be awaited first!");
47803 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_clone_ptr(arg);
47804 return nativeResponseValue;
47806 // struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_clone(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR orig);
47808 export function ProbabilisticScoringDecayParameters_clone(orig: bigint): bigint {
47809 if(!isWasmInitialized) {
47810 throw new Error("initializeWasm() must be awaited first!");
47812 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_clone(orig);
47813 return nativeResponseValue;
47815 // MUST_USE_RES struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_default(void);
47817 export function ProbabilisticScoringDecayParameters_default(): bigint {
47818 if(!isWasmInitialized) {
47819 throw new Error("initializeWasm() must be awaited first!");
47821 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_default();
47822 return nativeResponseValue;
47824 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringDecayParameters decay_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
47826 export function ProbabilisticScorer_new(decay_params: bigint, network_graph: bigint, logger: bigint): bigint {
47827 if(!isWasmInitialized) {
47828 throw new Error("initializeWasm() must be awaited first!");
47830 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(decay_params, network_graph, logger);
47831 return nativeResponseValue;
47833 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
47835 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
47836 if(!isWasmInitialized) {
47837 throw new Error("initializeWasm() must be awaited first!");
47839 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
47840 // debug statements here
47842 // 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);
47844 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
47845 if(!isWasmInitialized) {
47846 throw new Error("initializeWasm() must be awaited first!");
47848 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
47849 return nativeResponseValue;
47851 // 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);
47853 export function ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg: bigint, scid: bigint, target: bigint): bigint {
47854 if(!isWasmInitialized) {
47855 throw new Error("initializeWasm() must be awaited first!");
47857 const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg, scid, target);
47858 return nativeResponseValue;
47860 // 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);
47862 export function ProbabilisticScorer_historical_estimated_payment_success_probability(this_arg: bigint, scid: bigint, target: bigint, amount_msat: bigint, params: bigint): bigint {
47863 if(!isWasmInitialized) {
47864 throw new Error("initializeWasm() must be awaited first!");
47866 const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_payment_success_probability(this_arg, scid, target, amount_msat, params);
47867 return nativeResponseValue;
47869 // struct LDKScoreLookUp ProbabilisticScorer_as_ScoreLookUp(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
47871 export function ProbabilisticScorer_as_ScoreLookUp(this_arg: bigint): bigint {
47872 if(!isWasmInitialized) {
47873 throw new Error("initializeWasm() must be awaited first!");
47875 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_ScoreLookUp(this_arg);
47876 return nativeResponseValue;
47878 // struct LDKScoreUpdate ProbabilisticScorer_as_ScoreUpdate(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
47880 export function ProbabilisticScorer_as_ScoreUpdate(this_arg: bigint): bigint {
47881 if(!isWasmInitialized) {
47882 throw new Error("initializeWasm() must be awaited first!");
47884 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_ScoreUpdate(this_arg);
47885 return nativeResponseValue;
47887 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
47889 export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
47890 if(!isWasmInitialized) {
47891 throw new Error("initializeWasm() must be awaited first!");
47893 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
47894 return nativeResponseValue;
47896 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
47898 export function ProbabilisticScorer_write(obj: bigint): number {
47899 if(!isWasmInitialized) {
47900 throw new Error("initializeWasm() must be awaited first!");
47902 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
47903 return nativeResponseValue;
47905 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringDecayParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
47907 export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
47908 if(!isWasmInitialized) {
47909 throw new Error("initializeWasm() must be awaited first!");
47911 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
47912 return nativeResponseValue;
47914 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
47916 export function DelayedPaymentOutputDescriptor_free(this_obj: bigint): void {
47917 if(!isWasmInitialized) {
47918 throw new Error("initializeWasm() must be awaited first!");
47920 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
47921 // debug statements here
47923 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47925 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
47926 if(!isWasmInitialized) {
47927 throw new Error("initializeWasm() must be awaited first!");
47929 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
47930 return nativeResponseValue;
47932 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
47934 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
47935 if(!isWasmInitialized) {
47936 throw new Error("initializeWasm() must be awaited first!");
47938 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
47939 // debug statements here
47941 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47943 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: bigint): number {
47944 if(!isWasmInitialized) {
47945 throw new Error("initializeWasm() must be awaited first!");
47947 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
47948 return nativeResponseValue;
47950 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
47952 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
47953 if(!isWasmInitialized) {
47954 throw new Error("initializeWasm() must be awaited first!");
47956 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
47957 // debug statements here
47959 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47961 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: bigint): number {
47962 if(!isWasmInitialized) {
47963 throw new Error("initializeWasm() must be awaited first!");
47965 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
47966 return nativeResponseValue;
47968 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
47970 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: bigint, val: number): void {
47971 if(!isWasmInitialized) {
47972 throw new Error("initializeWasm() must be awaited first!");
47974 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
47975 // debug statements here
47977 // struct LDKTxOut DelayedPaymentOutputDescriptor_get_output(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47979 export function DelayedPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
47980 if(!isWasmInitialized) {
47981 throw new Error("initializeWasm() must be awaited first!");
47983 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_output(this_ptr);
47984 return nativeResponseValue;
47986 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
47988 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
47989 if(!isWasmInitialized) {
47990 throw new Error("initializeWasm() must be awaited first!");
47992 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
47993 // debug statements here
47995 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
47997 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: bigint): number {
47998 if(!isWasmInitialized) {
47999 throw new Error("initializeWasm() must be awaited first!");
48001 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
48002 return nativeResponseValue;
48004 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
48006 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: bigint, val: number): void {
48007 if(!isWasmInitialized) {
48008 throw new Error("initializeWasm() must be awaited first!");
48010 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
48011 // debug statements here
48013 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
48015 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
48016 if(!isWasmInitialized) {
48017 throw new Error("initializeWasm() must be awaited first!");
48019 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
48020 return nativeResponseValue;
48022 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
48024 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
48025 if(!isWasmInitialized) {
48026 throw new Error("initializeWasm() must be awaited first!");
48028 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
48029 // debug statements here
48031 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
48033 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
48034 if(!isWasmInitialized) {
48035 throw new Error("initializeWasm() must be awaited first!");
48037 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
48038 return nativeResponseValue;
48040 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
48042 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
48043 if(!isWasmInitialized) {
48044 throw new Error("initializeWasm() must be awaited first!");
48046 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
48047 // debug statements here
48049 // MUST_USE_RES struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_new(struct LDKOutPoint outpoint_arg, struct LDKPublicKey per_commitment_point_arg, uint16_t to_self_delay_arg, struct LDKTxOut output_arg, struct LDKPublicKey revocation_pubkey_arg, struct LDKThirtyTwoBytes channel_keys_id_arg, uint64_t channel_value_satoshis_arg);
48051 export function DelayedPaymentOutputDescriptor_new(outpoint_arg: bigint, per_commitment_point_arg: number, to_self_delay_arg: number, output_arg: bigint, revocation_pubkey_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): bigint {
48052 if(!isWasmInitialized) {
48053 throw new Error("initializeWasm() must be awaited first!");
48055 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);
48056 return nativeResponseValue;
48058 // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
48060 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
48061 if(!isWasmInitialized) {
48062 throw new Error("initializeWasm() must be awaited first!");
48064 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
48065 return nativeResponseValue;
48067 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
48069 export function DelayedPaymentOutputDescriptor_clone(orig: bigint): bigint {
48070 if(!isWasmInitialized) {
48071 throw new Error("initializeWasm() must be awaited first!");
48073 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
48074 return nativeResponseValue;
48076 // uint64_t DelayedPaymentOutputDescriptor_hash(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR o);
48078 export function DelayedPaymentOutputDescriptor_hash(o: bigint): bigint {
48079 if(!isWasmInitialized) {
48080 throw new Error("initializeWasm() must be awaited first!");
48082 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_hash(o);
48083 return nativeResponseValue;
48085 // bool DelayedPaymentOutputDescriptor_eq(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR b);
48087 export function DelayedPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
48088 if(!isWasmInitialized) {
48089 throw new Error("initializeWasm() must be awaited first!");
48091 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_eq(a, b);
48092 return nativeResponseValue;
48094 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
48096 export function DelayedPaymentOutputDescriptor_write(obj: bigint): number {
48097 if(!isWasmInitialized) {
48098 throw new Error("initializeWasm() must be awaited first!");
48100 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
48101 return nativeResponseValue;
48103 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
48105 export function DelayedPaymentOutputDescriptor_read(ser: number): bigint {
48106 if(!isWasmInitialized) {
48107 throw new Error("initializeWasm() must be awaited first!");
48109 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
48110 return nativeResponseValue;
48112 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
48114 export function StaticPaymentOutputDescriptor_free(this_obj: bigint): void {
48115 if(!isWasmInitialized) {
48116 throw new Error("initializeWasm() must be awaited first!");
48118 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
48119 // debug statements here
48121 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
48123 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
48124 if(!isWasmInitialized) {
48125 throw new Error("initializeWasm() must be awaited first!");
48127 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
48128 return nativeResponseValue;
48130 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
48132 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
48133 if(!isWasmInitialized) {
48134 throw new Error("initializeWasm() must be awaited first!");
48136 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
48137 // debug statements here
48139 // struct LDKTxOut StaticPaymentOutputDescriptor_get_output(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
48141 export function StaticPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
48142 if(!isWasmInitialized) {
48143 throw new Error("initializeWasm() must be awaited first!");
48145 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_output(this_ptr);
48146 return nativeResponseValue;
48148 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
48150 export function StaticPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
48151 if(!isWasmInitialized) {
48152 throw new Error("initializeWasm() must be awaited first!");
48154 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
48155 // debug statements here
48157 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
48159 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
48160 if(!isWasmInitialized) {
48161 throw new Error("initializeWasm() must be awaited first!");
48163 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
48164 return nativeResponseValue;
48166 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
48168 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
48169 if(!isWasmInitialized) {
48170 throw new Error("initializeWasm() must be awaited first!");
48172 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
48173 // debug statements here
48175 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
48177 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
48178 if(!isWasmInitialized) {
48179 throw new Error("initializeWasm() must be awaited first!");
48181 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
48182 return nativeResponseValue;
48184 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
48186 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
48187 if(!isWasmInitialized) {
48188 throw new Error("initializeWasm() must be awaited first!");
48190 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
48191 // debug statements here
48193 // struct LDKChannelTransactionParameters StaticPaymentOutputDescriptor_get_channel_transaction_parameters(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
48195 export function StaticPaymentOutputDescriptor_get_channel_transaction_parameters(this_ptr: bigint): bigint {
48196 if(!isWasmInitialized) {
48197 throw new Error("initializeWasm() must be awaited first!");
48199 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_transaction_parameters(this_ptr);
48200 return nativeResponseValue;
48202 // void StaticPaymentOutputDescriptor_set_channel_transaction_parameters(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKChannelTransactionParameters val);
48204 export function StaticPaymentOutputDescriptor_set_channel_transaction_parameters(this_ptr: bigint, val: bigint): void {
48205 if(!isWasmInitialized) {
48206 throw new Error("initializeWasm() must be awaited first!");
48208 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_transaction_parameters(this_ptr, val);
48209 // debug statements here
48211 // 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);
48213 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 {
48214 if(!isWasmInitialized) {
48215 throw new Error("initializeWasm() must be awaited first!");
48217 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg, channel_transaction_parameters_arg);
48218 return nativeResponseValue;
48220 // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
48222 export function StaticPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
48223 if(!isWasmInitialized) {
48224 throw new Error("initializeWasm() must be awaited first!");
48226 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
48227 return nativeResponseValue;
48229 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
48231 export function StaticPaymentOutputDescriptor_clone(orig: bigint): bigint {
48232 if(!isWasmInitialized) {
48233 throw new Error("initializeWasm() must be awaited first!");
48235 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
48236 return nativeResponseValue;
48238 // uint64_t StaticPaymentOutputDescriptor_hash(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR o);
48240 export function StaticPaymentOutputDescriptor_hash(o: bigint): bigint {
48241 if(!isWasmInitialized) {
48242 throw new Error("initializeWasm() must be awaited first!");
48244 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_hash(o);
48245 return nativeResponseValue;
48247 // bool StaticPaymentOutputDescriptor_eq(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR b);
48249 export function StaticPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
48250 if(!isWasmInitialized) {
48251 throw new Error("initializeWasm() must be awaited first!");
48253 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_eq(a, b);
48254 return nativeResponseValue;
48256 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ StaticPaymentOutputDescriptor_witness_script(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_arg);
48258 export function StaticPaymentOutputDescriptor_witness_script(this_arg: bigint): bigint {
48259 if(!isWasmInitialized) {
48260 throw new Error("initializeWasm() must be awaited first!");
48262 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_witness_script(this_arg);
48263 return nativeResponseValue;
48265 // MUST_USE_RES uintptr_t StaticPaymentOutputDescriptor_max_witness_length(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_arg);
48267 export function StaticPaymentOutputDescriptor_max_witness_length(this_arg: bigint): number {
48268 if(!isWasmInitialized) {
48269 throw new Error("initializeWasm() must be awaited first!");
48271 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_max_witness_length(this_arg);
48272 return nativeResponseValue;
48274 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
48276 export function StaticPaymentOutputDescriptor_write(obj: bigint): number {
48277 if(!isWasmInitialized) {
48278 throw new Error("initializeWasm() must be awaited first!");
48280 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
48281 return nativeResponseValue;
48283 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
48285 export function StaticPaymentOutputDescriptor_read(ser: number): bigint {
48286 if(!isWasmInitialized) {
48287 throw new Error("initializeWasm() must be awaited first!");
48289 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
48290 return nativeResponseValue;
48292 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
48294 export function SpendableOutputDescriptor_free(this_ptr: bigint): void {
48295 if(!isWasmInitialized) {
48296 throw new Error("initializeWasm() must be awaited first!");
48298 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
48299 // debug statements here
48301 // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
48303 export function SpendableOutputDescriptor_clone_ptr(arg: bigint): bigint {
48304 if(!isWasmInitialized) {
48305 throw new Error("initializeWasm() must be awaited first!");
48307 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
48308 return nativeResponseValue;
48310 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
48312 export function SpendableOutputDescriptor_clone(orig: bigint): bigint {
48313 if(!isWasmInitialized) {
48314 throw new Error("initializeWasm() must be awaited first!");
48316 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
48317 return nativeResponseValue;
48319 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
48321 export function SpendableOutputDescriptor_static_output(outpoint: bigint, output: bigint): bigint {
48322 if(!isWasmInitialized) {
48323 throw new Error("initializeWasm() must be awaited first!");
48325 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
48326 return nativeResponseValue;
48328 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
48330 export function SpendableOutputDescriptor_delayed_payment_output(a: bigint): bigint {
48331 if(!isWasmInitialized) {
48332 throw new Error("initializeWasm() must be awaited first!");
48334 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
48335 return nativeResponseValue;
48337 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
48339 export function SpendableOutputDescriptor_static_payment_output(a: bigint): bigint {
48340 if(!isWasmInitialized) {
48341 throw new Error("initializeWasm() must be awaited first!");
48343 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
48344 return nativeResponseValue;
48346 // uint64_t SpendableOutputDescriptor_hash(const struct LDKSpendableOutputDescriptor *NONNULL_PTR o);
48348 export function SpendableOutputDescriptor_hash(o: bigint): bigint {
48349 if(!isWasmInitialized) {
48350 throw new Error("initializeWasm() must be awaited first!");
48352 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_hash(o);
48353 return nativeResponseValue;
48355 // bool SpendableOutputDescriptor_eq(const struct LDKSpendableOutputDescriptor *NONNULL_PTR a, const struct LDKSpendableOutputDescriptor *NONNULL_PTR b);
48357 export function SpendableOutputDescriptor_eq(a: bigint, b: bigint): boolean {
48358 if(!isWasmInitialized) {
48359 throw new Error("initializeWasm() must be awaited first!");
48361 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_eq(a, b);
48362 return nativeResponseValue;
48364 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
48366 export function SpendableOutputDescriptor_write(obj: bigint): number {
48367 if(!isWasmInitialized) {
48368 throw new Error("initializeWasm() must be awaited first!");
48370 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
48371 return nativeResponseValue;
48373 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
48375 export function SpendableOutputDescriptor_read(ser: number): bigint {
48376 if(!isWasmInitialized) {
48377 throw new Error("initializeWasm() must be awaited first!");
48379 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
48380 return nativeResponseValue;
48382 // MUST_USE_RES struct LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ 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);
48384 export function SpendableOutputDescriptor_create_spendable_outputs_psbt(descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number, locktime: bigint): bigint {
48385 if(!isWasmInitialized) {
48386 throw new Error("initializeWasm() must be awaited first!");
48388 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_create_spendable_outputs_psbt(descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
48389 return nativeResponseValue;
48391 // void ChannelDerivationParameters_free(struct LDKChannelDerivationParameters this_obj);
48393 export function ChannelDerivationParameters_free(this_obj: bigint): void {
48394 if(!isWasmInitialized) {
48395 throw new Error("initializeWasm() must be awaited first!");
48397 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_free(this_obj);
48398 // debug statements here
48400 // uint64_t ChannelDerivationParameters_get_value_satoshis(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
48402 export function ChannelDerivationParameters_get_value_satoshis(this_ptr: bigint): bigint {
48403 if(!isWasmInitialized) {
48404 throw new Error("initializeWasm() must be awaited first!");
48406 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_value_satoshis(this_ptr);
48407 return nativeResponseValue;
48409 // void ChannelDerivationParameters_set_value_satoshis(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, uint64_t val);
48411 export function ChannelDerivationParameters_set_value_satoshis(this_ptr: bigint, val: bigint): void {
48412 if(!isWasmInitialized) {
48413 throw new Error("initializeWasm() must be awaited first!");
48415 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_value_satoshis(this_ptr, val);
48416 // debug statements here
48418 // const uint8_t (*ChannelDerivationParameters_get_keys_id(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr))[32];
48420 export function ChannelDerivationParameters_get_keys_id(this_ptr: bigint): number {
48421 if(!isWasmInitialized) {
48422 throw new Error("initializeWasm() must be awaited first!");
48424 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_keys_id(this_ptr);
48425 return nativeResponseValue;
48427 // void ChannelDerivationParameters_set_keys_id(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
48429 export function ChannelDerivationParameters_set_keys_id(this_ptr: bigint, val: number): void {
48430 if(!isWasmInitialized) {
48431 throw new Error("initializeWasm() must be awaited first!");
48433 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_keys_id(this_ptr, val);
48434 // debug statements here
48436 // struct LDKChannelTransactionParameters ChannelDerivationParameters_get_transaction_parameters(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
48438 export function ChannelDerivationParameters_get_transaction_parameters(this_ptr: bigint): bigint {
48439 if(!isWasmInitialized) {
48440 throw new Error("initializeWasm() must be awaited first!");
48442 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_transaction_parameters(this_ptr);
48443 return nativeResponseValue;
48445 // void ChannelDerivationParameters_set_transaction_parameters(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKChannelTransactionParameters val);
48447 export function ChannelDerivationParameters_set_transaction_parameters(this_ptr: bigint, val: bigint): void {
48448 if(!isWasmInitialized) {
48449 throw new Error("initializeWasm() must be awaited first!");
48451 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_transaction_parameters(this_ptr, val);
48452 // debug statements here
48454 // MUST_USE_RES struct LDKChannelDerivationParameters ChannelDerivationParameters_new(uint64_t value_satoshis_arg, struct LDKThirtyTwoBytes keys_id_arg, struct LDKChannelTransactionParameters transaction_parameters_arg);
48456 export function ChannelDerivationParameters_new(value_satoshis_arg: bigint, keys_id_arg: number, transaction_parameters_arg: bigint): bigint {
48457 if(!isWasmInitialized) {
48458 throw new Error("initializeWasm() must be awaited first!");
48460 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_new(value_satoshis_arg, keys_id_arg, transaction_parameters_arg);
48461 return nativeResponseValue;
48463 // uint64_t ChannelDerivationParameters_clone_ptr(LDKChannelDerivationParameters *NONNULL_PTR arg);
48465 export function ChannelDerivationParameters_clone_ptr(arg: bigint): bigint {
48466 if(!isWasmInitialized) {
48467 throw new Error("initializeWasm() must be awaited first!");
48469 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone_ptr(arg);
48470 return nativeResponseValue;
48472 // struct LDKChannelDerivationParameters ChannelDerivationParameters_clone(const struct LDKChannelDerivationParameters *NONNULL_PTR orig);
48474 export function ChannelDerivationParameters_clone(orig: bigint): bigint {
48475 if(!isWasmInitialized) {
48476 throw new Error("initializeWasm() must be awaited first!");
48478 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone(orig);
48479 return nativeResponseValue;
48481 // bool ChannelDerivationParameters_eq(const struct LDKChannelDerivationParameters *NONNULL_PTR a, const struct LDKChannelDerivationParameters *NONNULL_PTR b);
48483 export function ChannelDerivationParameters_eq(a: bigint, b: bigint): boolean {
48484 if(!isWasmInitialized) {
48485 throw new Error("initializeWasm() must be awaited first!");
48487 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_eq(a, b);
48488 return nativeResponseValue;
48490 // struct LDKCVec_u8Z ChannelDerivationParameters_write(const struct LDKChannelDerivationParameters *NONNULL_PTR obj);
48492 export function ChannelDerivationParameters_write(obj: bigint): number {
48493 if(!isWasmInitialized) {
48494 throw new Error("initializeWasm() must be awaited first!");
48496 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_write(obj);
48497 return nativeResponseValue;
48499 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ ChannelDerivationParameters_read(struct LDKu8slice ser);
48501 export function ChannelDerivationParameters_read(ser: number): bigint {
48502 if(!isWasmInitialized) {
48503 throw new Error("initializeWasm() must be awaited first!");
48505 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_read(ser);
48506 return nativeResponseValue;
48508 // void HTLCDescriptor_free(struct LDKHTLCDescriptor this_obj);
48510 export function HTLCDescriptor_free(this_obj: bigint): void {
48511 if(!isWasmInitialized) {
48512 throw new Error("initializeWasm() must be awaited first!");
48514 const nativeResponseValue = wasm.TS_HTLCDescriptor_free(this_obj);
48515 // debug statements here
48517 // struct LDKChannelDerivationParameters HTLCDescriptor_get_channel_derivation_parameters(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
48519 export function HTLCDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
48520 if(!isWasmInitialized) {
48521 throw new Error("initializeWasm() must be awaited first!");
48523 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_channel_derivation_parameters(this_ptr);
48524 return nativeResponseValue;
48526 // void HTLCDescriptor_set_channel_derivation_parameters(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
48528 export function HTLCDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
48529 if(!isWasmInitialized) {
48530 throw new Error("initializeWasm() must be awaited first!");
48532 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_channel_derivation_parameters(this_ptr, val);
48533 // debug statements here
48535 // uint64_t HTLCDescriptor_get_per_commitment_number(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
48537 export function HTLCDescriptor_get_per_commitment_number(this_ptr: bigint): bigint {
48538 if(!isWasmInitialized) {
48539 throw new Error("initializeWasm() must be awaited first!");
48541 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_number(this_ptr);
48542 return nativeResponseValue;
48544 // void HTLCDescriptor_set_per_commitment_number(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, uint64_t val);
48546 export function HTLCDescriptor_set_per_commitment_number(this_ptr: bigint, val: bigint): void {
48547 if(!isWasmInitialized) {
48548 throw new Error("initializeWasm() must be awaited first!");
48550 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_number(this_ptr, val);
48551 // debug statements here
48553 // struct LDKPublicKey HTLCDescriptor_get_per_commitment_point(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
48555 export function HTLCDescriptor_get_per_commitment_point(this_ptr: bigint): number {
48556 if(!isWasmInitialized) {
48557 throw new Error("initializeWasm() must be awaited first!");
48559 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_point(this_ptr);
48560 return nativeResponseValue;
48562 // void HTLCDescriptor_set_per_commitment_point(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
48564 export function HTLCDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
48565 if(!isWasmInitialized) {
48566 throw new Error("initializeWasm() must be awaited first!");
48568 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_point(this_ptr, val);
48569 // debug statements here
48571 // uint32_t HTLCDescriptor_get_feerate_per_kw(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
48573 export function HTLCDescriptor_get_feerate_per_kw(this_ptr: bigint): number {
48574 if(!isWasmInitialized) {
48575 throw new Error("initializeWasm() must be awaited first!");
48577 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_feerate_per_kw(this_ptr);
48578 return nativeResponseValue;
48580 // void HTLCDescriptor_set_feerate_per_kw(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, uint32_t val);
48582 export function HTLCDescriptor_set_feerate_per_kw(this_ptr: bigint, val: number): void {
48583 if(!isWasmInitialized) {
48584 throw new Error("initializeWasm() must be awaited first!");
48586 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_feerate_per_kw(this_ptr, val);
48587 // debug statements here
48589 // struct LDKHTLCOutputInCommitment HTLCDescriptor_get_htlc(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
48591 export function HTLCDescriptor_get_htlc(this_ptr: bigint): bigint {
48592 if(!isWasmInitialized) {
48593 throw new Error("initializeWasm() must be awaited first!");
48595 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_htlc(this_ptr);
48596 return nativeResponseValue;
48598 // void HTLCDescriptor_set_htlc(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKHTLCOutputInCommitment val);
48600 export function HTLCDescriptor_set_htlc(this_ptr: bigint, val: bigint): void {
48601 if(!isWasmInitialized) {
48602 throw new Error("initializeWasm() must be awaited first!");
48604 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_htlc(this_ptr, val);
48605 // debug statements here
48607 // struct LDKCOption_ThirtyTwoBytesZ HTLCDescriptor_get_preimage(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
48609 export function HTLCDescriptor_get_preimage(this_ptr: bigint): bigint {
48610 if(!isWasmInitialized) {
48611 throw new Error("initializeWasm() must be awaited first!");
48613 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_preimage(this_ptr);
48614 return nativeResponseValue;
48616 // void HTLCDescriptor_set_preimage(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
48618 export function HTLCDescriptor_set_preimage(this_ptr: bigint, val: bigint): void {
48619 if(!isWasmInitialized) {
48620 throw new Error("initializeWasm() must be awaited first!");
48622 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_preimage(this_ptr, val);
48623 // debug statements here
48625 // struct LDKECDSASignature HTLCDescriptor_get_counterparty_sig(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
48627 export function HTLCDescriptor_get_counterparty_sig(this_ptr: bigint): number {
48628 if(!isWasmInitialized) {
48629 throw new Error("initializeWasm() must be awaited first!");
48631 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_counterparty_sig(this_ptr);
48632 return nativeResponseValue;
48634 // void HTLCDescriptor_set_counterparty_sig(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
48636 export function HTLCDescriptor_set_counterparty_sig(this_ptr: bigint, val: number): void {
48637 if(!isWasmInitialized) {
48638 throw new Error("initializeWasm() must be awaited first!");
48640 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_counterparty_sig(this_ptr, val);
48641 // debug statements here
48643 // uint64_t HTLCDescriptor_clone_ptr(LDKHTLCDescriptor *NONNULL_PTR arg);
48645 export function HTLCDescriptor_clone_ptr(arg: bigint): bigint {
48646 if(!isWasmInitialized) {
48647 throw new Error("initializeWasm() must be awaited first!");
48649 const nativeResponseValue = wasm.TS_HTLCDescriptor_clone_ptr(arg);
48650 return nativeResponseValue;
48652 // struct LDKHTLCDescriptor HTLCDescriptor_clone(const struct LDKHTLCDescriptor *NONNULL_PTR orig);
48654 export function HTLCDescriptor_clone(orig: bigint): bigint {
48655 if(!isWasmInitialized) {
48656 throw new Error("initializeWasm() must be awaited first!");
48658 const nativeResponseValue = wasm.TS_HTLCDescriptor_clone(orig);
48659 return nativeResponseValue;
48661 // bool HTLCDescriptor_eq(const struct LDKHTLCDescriptor *NONNULL_PTR a, const struct LDKHTLCDescriptor *NONNULL_PTR b);
48663 export function HTLCDescriptor_eq(a: bigint, b: bigint): boolean {
48664 if(!isWasmInitialized) {
48665 throw new Error("initializeWasm() must be awaited first!");
48667 const nativeResponseValue = wasm.TS_HTLCDescriptor_eq(a, b);
48668 return nativeResponseValue;
48670 // struct LDKCVec_u8Z HTLCDescriptor_write(const struct LDKHTLCDescriptor *NONNULL_PTR obj);
48672 export function HTLCDescriptor_write(obj: bigint): number {
48673 if(!isWasmInitialized) {
48674 throw new Error("initializeWasm() must be awaited first!");
48676 const nativeResponseValue = wasm.TS_HTLCDescriptor_write(obj);
48677 return nativeResponseValue;
48679 // struct LDKCResult_HTLCDescriptorDecodeErrorZ HTLCDescriptor_read(struct LDKu8slice ser);
48681 export function HTLCDescriptor_read(ser: number): bigint {
48682 if(!isWasmInitialized) {
48683 throw new Error("initializeWasm() must be awaited first!");
48685 const nativeResponseValue = wasm.TS_HTLCDescriptor_read(ser);
48686 return nativeResponseValue;
48688 // MUST_USE_RES struct LDKOutPoint HTLCDescriptor_outpoint(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
48690 export function HTLCDescriptor_outpoint(this_arg: bigint): bigint {
48691 if(!isWasmInitialized) {
48692 throw new Error("initializeWasm() must be awaited first!");
48694 const nativeResponseValue = wasm.TS_HTLCDescriptor_outpoint(this_arg);
48695 return nativeResponseValue;
48697 // MUST_USE_RES struct LDKTxOut HTLCDescriptor_previous_utxo(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
48699 export function HTLCDescriptor_previous_utxo(this_arg: bigint): bigint {
48700 if(!isWasmInitialized) {
48701 throw new Error("initializeWasm() must be awaited first!");
48703 const nativeResponseValue = wasm.TS_HTLCDescriptor_previous_utxo(this_arg);
48704 return nativeResponseValue;
48706 // MUST_USE_RES struct LDKTxIn HTLCDescriptor_unsigned_tx_input(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
48708 export function HTLCDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
48709 if(!isWasmInitialized) {
48710 throw new Error("initializeWasm() must be awaited first!");
48712 const nativeResponseValue = wasm.TS_HTLCDescriptor_unsigned_tx_input(this_arg);
48713 return nativeResponseValue;
48715 // MUST_USE_RES struct LDKTxOut HTLCDescriptor_tx_output(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
48717 export function HTLCDescriptor_tx_output(this_arg: bigint): bigint {
48718 if(!isWasmInitialized) {
48719 throw new Error("initializeWasm() must be awaited first!");
48721 const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_output(this_arg);
48722 return nativeResponseValue;
48724 // MUST_USE_RES struct LDKCVec_u8Z HTLCDescriptor_witness_script(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
48726 export function HTLCDescriptor_witness_script(this_arg: bigint): number {
48727 if(!isWasmInitialized) {
48728 throw new Error("initializeWasm() must be awaited first!");
48730 const nativeResponseValue = wasm.TS_HTLCDescriptor_witness_script(this_arg);
48731 return nativeResponseValue;
48733 // MUST_USE_RES struct LDKWitness HTLCDescriptor_tx_input_witness(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, struct LDKECDSASignature signature, struct LDKu8slice witness_script);
48735 export function HTLCDescriptor_tx_input_witness(this_arg: bigint, signature: number, witness_script: number): number {
48736 if(!isWasmInitialized) {
48737 throw new Error("initializeWasm() must be awaited first!");
48739 const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_input_witness(this_arg, signature, witness_script);
48740 return nativeResponseValue;
48742 // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner HTLCDescriptor_derive_channel_signer(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
48744 export function HTLCDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
48745 if(!isWasmInitialized) {
48746 throw new Error("initializeWasm() must be awaited first!");
48748 const nativeResponseValue = wasm.TS_HTLCDescriptor_derive_channel_signer(this_arg, signer_provider);
48749 return nativeResponseValue;
48751 // void ChannelSigner_free(struct LDKChannelSigner this_ptr);
48753 export function ChannelSigner_free(this_ptr: bigint): void {
48754 if(!isWasmInitialized) {
48755 throw new Error("initializeWasm() must be awaited first!");
48757 const nativeResponseValue = wasm.TS_ChannelSigner_free(this_ptr);
48758 // debug statements here
48760 // void EcdsaChannelSigner_free(struct LDKEcdsaChannelSigner this_ptr);
48762 export function EcdsaChannelSigner_free(this_ptr: bigint): void {
48763 if(!isWasmInitialized) {
48764 throw new Error("initializeWasm() must be awaited first!");
48766 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_free(this_ptr);
48767 // debug statements here
48769 // uint64_t WriteableEcdsaChannelSigner_clone_ptr(LDKWriteableEcdsaChannelSigner *NONNULL_PTR arg);
48771 export function WriteableEcdsaChannelSigner_clone_ptr(arg: bigint): bigint {
48772 if(!isWasmInitialized) {
48773 throw new Error("initializeWasm() must be awaited first!");
48775 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone_ptr(arg);
48776 return nativeResponseValue;
48778 // struct LDKWriteableEcdsaChannelSigner WriteableEcdsaChannelSigner_clone(const struct LDKWriteableEcdsaChannelSigner *NONNULL_PTR orig);
48780 export function WriteableEcdsaChannelSigner_clone(orig: bigint): bigint {
48781 if(!isWasmInitialized) {
48782 throw new Error("initializeWasm() must be awaited first!");
48784 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone(orig);
48785 return nativeResponseValue;
48787 // void WriteableEcdsaChannelSigner_free(struct LDKWriteableEcdsaChannelSigner this_ptr);
48789 export function WriteableEcdsaChannelSigner_free(this_ptr: bigint): void {
48790 if(!isWasmInitialized) {
48791 throw new Error("initializeWasm() must be awaited first!");
48793 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_free(this_ptr);
48794 // debug statements here
48796 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
48798 export function Recipient_clone(orig: bigint): Recipient {
48799 if(!isWasmInitialized) {
48800 throw new Error("initializeWasm() must be awaited first!");
48802 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
48803 return nativeResponseValue;
48805 // enum LDKRecipient Recipient_node(void);
48807 export function Recipient_node(): Recipient {
48808 if(!isWasmInitialized) {
48809 throw new Error("initializeWasm() must be awaited first!");
48811 const nativeResponseValue = wasm.TS_Recipient_node();
48812 return nativeResponseValue;
48814 // enum LDKRecipient Recipient_phantom_node(void);
48816 export function Recipient_phantom_node(): Recipient {
48817 if(!isWasmInitialized) {
48818 throw new Error("initializeWasm() must be awaited first!");
48820 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
48821 return nativeResponseValue;
48823 // void EntropySource_free(struct LDKEntropySource this_ptr);
48825 export function EntropySource_free(this_ptr: bigint): void {
48826 if(!isWasmInitialized) {
48827 throw new Error("initializeWasm() must be awaited first!");
48829 const nativeResponseValue = wasm.TS_EntropySource_free(this_ptr);
48830 // debug statements here
48832 // void NodeSigner_free(struct LDKNodeSigner this_ptr);
48834 export function NodeSigner_free(this_ptr: bigint): void {
48835 if(!isWasmInitialized) {
48836 throw new Error("initializeWasm() must be awaited first!");
48838 const nativeResponseValue = wasm.TS_NodeSigner_free(this_ptr);
48839 // debug statements here
48841 // void SignerProvider_free(struct LDKSignerProvider this_ptr);
48843 export function SignerProvider_free(this_ptr: bigint): void {
48844 if(!isWasmInitialized) {
48845 throw new Error("initializeWasm() must be awaited first!");
48847 const nativeResponseValue = wasm.TS_SignerProvider_free(this_ptr);
48848 // debug statements here
48850 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
48852 export function InMemorySigner_free(this_obj: bigint): void {
48853 if(!isWasmInitialized) {
48854 throw new Error("initializeWasm() must be awaited first!");
48856 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
48857 // debug statements here
48859 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
48861 export function InMemorySigner_get_funding_key(this_ptr: bigint): number {
48862 if(!isWasmInitialized) {
48863 throw new Error("initializeWasm() must be awaited first!");
48865 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
48866 return nativeResponseValue;
48868 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
48870 export function InMemorySigner_set_funding_key(this_ptr: bigint, val: number): void {
48871 if(!isWasmInitialized) {
48872 throw new Error("initializeWasm() must be awaited first!");
48874 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
48875 // debug statements here
48877 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
48879 export function InMemorySigner_get_revocation_base_key(this_ptr: bigint): number {
48880 if(!isWasmInitialized) {
48881 throw new Error("initializeWasm() must be awaited first!");
48883 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
48884 return nativeResponseValue;
48886 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
48888 export function InMemorySigner_set_revocation_base_key(this_ptr: bigint, val: number): void {
48889 if(!isWasmInitialized) {
48890 throw new Error("initializeWasm() must be awaited first!");
48892 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
48893 // debug statements here
48895 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
48897 export function InMemorySigner_get_payment_key(this_ptr: bigint): number {
48898 if(!isWasmInitialized) {
48899 throw new Error("initializeWasm() must be awaited first!");
48901 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
48902 return nativeResponseValue;
48904 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
48906 export function InMemorySigner_set_payment_key(this_ptr: bigint, val: number): void {
48907 if(!isWasmInitialized) {
48908 throw new Error("initializeWasm() must be awaited first!");
48910 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
48911 // debug statements here
48913 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
48915 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: bigint): number {
48916 if(!isWasmInitialized) {
48917 throw new Error("initializeWasm() must be awaited first!");
48919 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
48920 return nativeResponseValue;
48922 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
48924 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: bigint, val: number): void {
48925 if(!isWasmInitialized) {
48926 throw new Error("initializeWasm() must be awaited first!");
48928 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
48929 // debug statements here
48931 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
48933 export function InMemorySigner_get_htlc_base_key(this_ptr: bigint): number {
48934 if(!isWasmInitialized) {
48935 throw new Error("initializeWasm() must be awaited first!");
48937 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
48938 return nativeResponseValue;
48940 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
48942 export function InMemorySigner_set_htlc_base_key(this_ptr: bigint, val: number): void {
48943 if(!isWasmInitialized) {
48944 throw new Error("initializeWasm() must be awaited first!");
48946 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
48947 // debug statements here
48949 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
48951 export function InMemorySigner_get_commitment_seed(this_ptr: bigint): number {
48952 if(!isWasmInitialized) {
48953 throw new Error("initializeWasm() must be awaited first!");
48955 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
48956 return nativeResponseValue;
48958 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
48960 export function InMemorySigner_set_commitment_seed(this_ptr: bigint, val: number): void {
48961 if(!isWasmInitialized) {
48962 throw new Error("initializeWasm() must be awaited first!");
48964 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
48965 // debug statements here
48967 // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
48969 export function InMemorySigner_clone_ptr(arg: bigint): bigint {
48970 if(!isWasmInitialized) {
48971 throw new Error("initializeWasm() must be awaited first!");
48973 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
48974 return nativeResponseValue;
48976 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
48978 export function InMemorySigner_clone(orig: bigint): bigint {
48979 if(!isWasmInitialized) {
48980 throw new Error("initializeWasm() must be awaited first!");
48982 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
48983 return nativeResponseValue;
48985 // 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);
48987 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 {
48988 if(!isWasmInitialized) {
48989 throw new Error("initializeWasm() must be awaited first!");
48991 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);
48992 return nativeResponseValue;
48994 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
48996 export function InMemorySigner_counterparty_pubkeys(this_arg: bigint): bigint {
48997 if(!isWasmInitialized) {
48998 throw new Error("initializeWasm() must be awaited first!");
49000 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
49001 return nativeResponseValue;
49003 // MUST_USE_RES struct LDKCOption_u16Z InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
49005 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: bigint): bigint {
49006 if(!isWasmInitialized) {
49007 throw new Error("initializeWasm() must be awaited first!");
49009 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
49010 return nativeResponseValue;
49012 // MUST_USE_RES struct LDKCOption_u16Z InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
49014 export function InMemorySigner_holder_selected_contest_delay(this_arg: bigint): bigint {
49015 if(!isWasmInitialized) {
49016 throw new Error("initializeWasm() must be awaited first!");
49018 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
49019 return nativeResponseValue;
49021 // MUST_USE_RES struct LDKCOption_boolZ InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
49023 export function InMemorySigner_is_outbound(this_arg: bigint): bigint {
49024 if(!isWasmInitialized) {
49025 throw new Error("initializeWasm() must be awaited first!");
49027 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
49028 return nativeResponseValue;
49030 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
49032 export function InMemorySigner_funding_outpoint(this_arg: bigint): bigint {
49033 if(!isWasmInitialized) {
49034 throw new Error("initializeWasm() must be awaited first!");
49036 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
49037 return nativeResponseValue;
49039 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
49041 export function InMemorySigner_get_channel_parameters(this_arg: bigint): bigint {
49042 if(!isWasmInitialized) {
49043 throw new Error("initializeWasm() must be awaited first!");
49045 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
49046 return nativeResponseValue;
49048 // MUST_USE_RES struct LDKChannelTypeFeatures InMemorySigner_channel_type_features(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
49050 export function InMemorySigner_channel_type_features(this_arg: bigint): bigint {
49051 if(!isWasmInitialized) {
49052 throw new Error("initializeWasm() must be awaited first!");
49054 const nativeResponseValue = wasm.TS_InMemorySigner_channel_type_features(this_arg);
49055 return nativeResponseValue;
49057 // MUST_USE_RES struct LDKCResult_CVec_CVec_u8ZZNoneZ InMemorySigner_sign_counterparty_payment_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR descriptor);
49059 export function InMemorySigner_sign_counterparty_payment_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
49060 if(!isWasmInitialized) {
49061 throw new Error("initializeWasm() must be awaited first!");
49063 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
49064 return nativeResponseValue;
49066 // MUST_USE_RES struct LDKCResult_CVec_CVec_u8ZZNoneZ InMemorySigner_sign_dynamic_p2wsh_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR descriptor);
49068 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
49069 if(!isWasmInitialized) {
49070 throw new Error("initializeWasm() must be awaited first!");
49072 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
49073 return nativeResponseValue;
49075 // struct LDKEntropySource InMemorySigner_as_EntropySource(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
49077 export function InMemorySigner_as_EntropySource(this_arg: bigint): bigint {
49078 if(!isWasmInitialized) {
49079 throw new Error("initializeWasm() must be awaited first!");
49081 const nativeResponseValue = wasm.TS_InMemorySigner_as_EntropySource(this_arg);
49082 return nativeResponseValue;
49084 // struct LDKChannelSigner InMemorySigner_as_ChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
49086 export function InMemorySigner_as_ChannelSigner(this_arg: bigint): bigint {
49087 if(!isWasmInitialized) {
49088 throw new Error("initializeWasm() must be awaited first!");
49090 const nativeResponseValue = wasm.TS_InMemorySigner_as_ChannelSigner(this_arg);
49091 return nativeResponseValue;
49093 // struct LDKEcdsaChannelSigner InMemorySigner_as_EcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
49095 export function InMemorySigner_as_EcdsaChannelSigner(this_arg: bigint): bigint {
49096 if(!isWasmInitialized) {
49097 throw new Error("initializeWasm() must be awaited first!");
49099 const nativeResponseValue = wasm.TS_InMemorySigner_as_EcdsaChannelSigner(this_arg);
49100 return nativeResponseValue;
49102 // struct LDKWriteableEcdsaChannelSigner InMemorySigner_as_WriteableEcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
49104 export function InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg: bigint): bigint {
49105 if(!isWasmInitialized) {
49106 throw new Error("initializeWasm() must be awaited first!");
49108 const nativeResponseValue = wasm.TS_InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg);
49109 return nativeResponseValue;
49111 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
49113 export function InMemorySigner_write(obj: bigint): number {
49114 if(!isWasmInitialized) {
49115 throw new Error("initializeWasm() must be awaited first!");
49117 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
49118 return nativeResponseValue;
49120 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKEntropySource arg);
49122 export function InMemorySigner_read(ser: number, arg: bigint): bigint {
49123 if(!isWasmInitialized) {
49124 throw new Error("initializeWasm() must be awaited first!");
49126 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
49127 return nativeResponseValue;
49129 // void KeysManager_free(struct LDKKeysManager this_obj);
49131 export function KeysManager_free(this_obj: bigint): void {
49132 if(!isWasmInitialized) {
49133 throw new Error("initializeWasm() must be awaited first!");
49135 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
49136 // debug statements here
49138 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
49140 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): bigint {
49141 if(!isWasmInitialized) {
49142 throw new Error("initializeWasm() must be awaited first!");
49144 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
49145 return nativeResponseValue;
49147 // MUST_USE_RES struct LDKSecretKey KeysManager_get_node_secret_key(const struct LDKKeysManager *NONNULL_PTR this_arg);
49149 export function KeysManager_get_node_secret_key(this_arg: bigint): number {
49150 if(!isWasmInitialized) {
49151 throw new Error("initializeWasm() must be awaited first!");
49153 const nativeResponseValue = wasm.TS_KeysManager_get_node_secret_key(this_arg);
49154 return nativeResponseValue;
49156 // 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]);
49158 export function KeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
49159 if(!isWasmInitialized) {
49160 throw new Error("initializeWasm() must be awaited first!");
49162 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
49163 return nativeResponseValue;
49165 // 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);
49167 export function KeysManager_sign_spendable_outputs_psbt(this_arg: bigint, descriptors: number, psbt: number): bigint {
49168 if(!isWasmInitialized) {
49169 throw new Error("initializeWasm() must be awaited first!");
49171 const nativeResponseValue = wasm.TS_KeysManager_sign_spendable_outputs_psbt(this_arg, descriptors, psbt);
49172 return nativeResponseValue;
49174 // MUST_USE_RES struct LDKCResult_TransactionNoneZ KeysManager_spend_spendable_outputs(const struct LDKKeysManager *NONNULL_PTR this_arg, struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_u32Z locktime);
49176 export function KeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number, locktime: bigint): bigint {
49177 if(!isWasmInitialized) {
49178 throw new Error("initializeWasm() must be awaited first!");
49180 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
49181 return nativeResponseValue;
49183 // struct LDKEntropySource KeysManager_as_EntropySource(const struct LDKKeysManager *NONNULL_PTR this_arg);
49185 export function KeysManager_as_EntropySource(this_arg: bigint): bigint {
49186 if(!isWasmInitialized) {
49187 throw new Error("initializeWasm() must be awaited first!");
49189 const nativeResponseValue = wasm.TS_KeysManager_as_EntropySource(this_arg);
49190 return nativeResponseValue;
49192 // struct LDKNodeSigner KeysManager_as_NodeSigner(const struct LDKKeysManager *NONNULL_PTR this_arg);
49194 export function KeysManager_as_NodeSigner(this_arg: bigint): bigint {
49195 if(!isWasmInitialized) {
49196 throw new Error("initializeWasm() must be awaited first!");
49198 const nativeResponseValue = wasm.TS_KeysManager_as_NodeSigner(this_arg);
49199 return nativeResponseValue;
49201 // struct LDKSignerProvider KeysManager_as_SignerProvider(const struct LDKKeysManager *NONNULL_PTR this_arg);
49203 export function KeysManager_as_SignerProvider(this_arg: bigint): bigint {
49204 if(!isWasmInitialized) {
49205 throw new Error("initializeWasm() must be awaited first!");
49207 const nativeResponseValue = wasm.TS_KeysManager_as_SignerProvider(this_arg);
49208 return nativeResponseValue;
49210 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
49212 export function PhantomKeysManager_free(this_obj: bigint): void {
49213 if(!isWasmInitialized) {
49214 throw new Error("initializeWasm() must be awaited first!");
49216 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
49217 // debug statements here
49219 // struct LDKEntropySource PhantomKeysManager_as_EntropySource(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
49221 export function PhantomKeysManager_as_EntropySource(this_arg: bigint): bigint {
49222 if(!isWasmInitialized) {
49223 throw new Error("initializeWasm() must be awaited first!");
49225 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_EntropySource(this_arg);
49226 return nativeResponseValue;
49228 // struct LDKNodeSigner PhantomKeysManager_as_NodeSigner(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
49230 export function PhantomKeysManager_as_NodeSigner(this_arg: bigint): bigint {
49231 if(!isWasmInitialized) {
49232 throw new Error("initializeWasm() must be awaited first!");
49234 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_NodeSigner(this_arg);
49235 return nativeResponseValue;
49237 // struct LDKSignerProvider PhantomKeysManager_as_SignerProvider(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
49239 export function PhantomKeysManager_as_SignerProvider(this_arg: bigint): bigint {
49240 if(!isWasmInitialized) {
49241 throw new Error("initializeWasm() must be awaited first!");
49243 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_SignerProvider(this_arg);
49244 return nativeResponseValue;
49246 // 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]);
49248 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): bigint {
49249 if(!isWasmInitialized) {
49250 throw new Error("initializeWasm() must be awaited first!");
49252 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
49253 return nativeResponseValue;
49255 // MUST_USE_RES struct LDKCResult_TransactionNoneZ PhantomKeysManager_spend_spendable_outputs(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg, struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_u32Z locktime);
49257 export function PhantomKeysManager_spend_spendable_outputs(this_arg: bigint, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number, locktime: bigint): bigint {
49258 if(!isWasmInitialized) {
49259 throw new Error("initializeWasm() must be awaited first!");
49261 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
49262 return nativeResponseValue;
49264 // 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]);
49266 export function PhantomKeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
49267 if(!isWasmInitialized) {
49268 throw new Error("initializeWasm() must be awaited first!");
49270 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
49271 return nativeResponseValue;
49273 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
49275 export function PhantomKeysManager_get_node_secret_key(this_arg: bigint): number {
49276 if(!isWasmInitialized) {
49277 throw new Error("initializeWasm() must be awaited first!");
49279 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_node_secret_key(this_arg);
49280 return nativeResponseValue;
49282 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_phantom_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
49284 export function PhantomKeysManager_get_phantom_node_secret_key(this_arg: bigint): number {
49285 if(!isWasmInitialized) {
49286 throw new Error("initializeWasm() must be awaited first!");
49288 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_phantom_node_secret_key(this_arg);
49289 return nativeResponseValue;
49291 // void OnionMessenger_free(struct LDKOnionMessenger this_obj);
49293 export function OnionMessenger_free(this_obj: bigint): void {
49294 if(!isWasmInitialized) {
49295 throw new Error("initializeWasm() must be awaited first!");
49297 const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
49298 // debug statements here
49300 // void MessageRouter_free(struct LDKMessageRouter this_ptr);
49302 export function MessageRouter_free(this_ptr: bigint): void {
49303 if(!isWasmInitialized) {
49304 throw new Error("initializeWasm() must be awaited first!");
49306 const nativeResponseValue = wasm.TS_MessageRouter_free(this_ptr);
49307 // debug statements here
49309 // void DefaultMessageRouter_free(struct LDKDefaultMessageRouter this_obj);
49311 export function DefaultMessageRouter_free(this_obj: bigint): void {
49312 if(!isWasmInitialized) {
49313 throw new Error("initializeWasm() must be awaited first!");
49315 const nativeResponseValue = wasm.TS_DefaultMessageRouter_free(this_obj);
49316 // debug statements here
49318 // MUST_USE_RES struct LDKDefaultMessageRouter DefaultMessageRouter_new(void);
49320 export function DefaultMessageRouter_new(): bigint {
49321 if(!isWasmInitialized) {
49322 throw new Error("initializeWasm() must be awaited first!");
49324 const nativeResponseValue = wasm.TS_DefaultMessageRouter_new();
49325 return nativeResponseValue;
49327 // struct LDKMessageRouter DefaultMessageRouter_as_MessageRouter(const struct LDKDefaultMessageRouter *NONNULL_PTR this_arg);
49329 export function DefaultMessageRouter_as_MessageRouter(this_arg: bigint): bigint {
49330 if(!isWasmInitialized) {
49331 throw new Error("initializeWasm() must be awaited first!");
49333 const nativeResponseValue = wasm.TS_DefaultMessageRouter_as_MessageRouter(this_arg);
49334 return nativeResponseValue;
49336 // void OnionMessagePath_free(struct LDKOnionMessagePath this_obj);
49338 export function OnionMessagePath_free(this_obj: bigint): void {
49339 if(!isWasmInitialized) {
49340 throw new Error("initializeWasm() must be awaited first!");
49342 const nativeResponseValue = wasm.TS_OnionMessagePath_free(this_obj);
49343 // debug statements here
49345 // struct LDKCVec_PublicKeyZ OnionMessagePath_get_intermediate_nodes(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
49347 export function OnionMessagePath_get_intermediate_nodes(this_ptr: bigint): number {
49348 if(!isWasmInitialized) {
49349 throw new Error("initializeWasm() must be awaited first!");
49351 const nativeResponseValue = wasm.TS_OnionMessagePath_get_intermediate_nodes(this_ptr);
49352 return nativeResponseValue;
49354 // void OnionMessagePath_set_intermediate_nodes(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKCVec_PublicKeyZ val);
49356 export function OnionMessagePath_set_intermediate_nodes(this_ptr: bigint, val: number): void {
49357 if(!isWasmInitialized) {
49358 throw new Error("initializeWasm() must be awaited first!");
49360 const nativeResponseValue = wasm.TS_OnionMessagePath_set_intermediate_nodes(this_ptr, val);
49361 // debug statements here
49363 // struct LDKDestination OnionMessagePath_get_destination(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
49365 export function OnionMessagePath_get_destination(this_ptr: bigint): bigint {
49366 if(!isWasmInitialized) {
49367 throw new Error("initializeWasm() must be awaited first!");
49369 const nativeResponseValue = wasm.TS_OnionMessagePath_get_destination(this_ptr);
49370 return nativeResponseValue;
49372 // void OnionMessagePath_set_destination(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKDestination val);
49374 export function OnionMessagePath_set_destination(this_ptr: bigint, val: bigint): void {
49375 if(!isWasmInitialized) {
49376 throw new Error("initializeWasm() must be awaited first!");
49378 const nativeResponseValue = wasm.TS_OnionMessagePath_set_destination(this_ptr, val);
49379 // debug statements here
49381 // MUST_USE_RES struct LDKOnionMessagePath OnionMessagePath_new(struct LDKCVec_PublicKeyZ intermediate_nodes_arg, struct LDKDestination destination_arg);
49383 export function OnionMessagePath_new(intermediate_nodes_arg: number, destination_arg: bigint): bigint {
49384 if(!isWasmInitialized) {
49385 throw new Error("initializeWasm() must be awaited first!");
49387 const nativeResponseValue = wasm.TS_OnionMessagePath_new(intermediate_nodes_arg, destination_arg);
49388 return nativeResponseValue;
49390 // uint64_t OnionMessagePath_clone_ptr(LDKOnionMessagePath *NONNULL_PTR arg);
49392 export function OnionMessagePath_clone_ptr(arg: bigint): bigint {
49393 if(!isWasmInitialized) {
49394 throw new Error("initializeWasm() must be awaited first!");
49396 const nativeResponseValue = wasm.TS_OnionMessagePath_clone_ptr(arg);
49397 return nativeResponseValue;
49399 // struct LDKOnionMessagePath OnionMessagePath_clone(const struct LDKOnionMessagePath *NONNULL_PTR orig);
49401 export function OnionMessagePath_clone(orig: bigint): bigint {
49402 if(!isWasmInitialized) {
49403 throw new Error("initializeWasm() must be awaited first!");
49405 const nativeResponseValue = wasm.TS_OnionMessagePath_clone(orig);
49406 return nativeResponseValue;
49408 // void Destination_free(struct LDKDestination this_ptr);
49410 export function Destination_free(this_ptr: bigint): void {
49411 if(!isWasmInitialized) {
49412 throw new Error("initializeWasm() must be awaited first!");
49414 const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
49415 // debug statements here
49417 // uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg);
49419 export function Destination_clone_ptr(arg: bigint): bigint {
49420 if(!isWasmInitialized) {
49421 throw new Error("initializeWasm() must be awaited first!");
49423 const nativeResponseValue = wasm.TS_Destination_clone_ptr(arg);
49424 return nativeResponseValue;
49426 // struct LDKDestination Destination_clone(const struct LDKDestination *NONNULL_PTR orig);
49428 export function Destination_clone(orig: bigint): bigint {
49429 if(!isWasmInitialized) {
49430 throw new Error("initializeWasm() must be awaited first!");
49432 const nativeResponseValue = wasm.TS_Destination_clone(orig);
49433 return nativeResponseValue;
49435 // struct LDKDestination Destination_node(struct LDKPublicKey a);
49437 export function Destination_node(a: number): bigint {
49438 if(!isWasmInitialized) {
49439 throw new Error("initializeWasm() must be awaited first!");
49441 const nativeResponseValue = wasm.TS_Destination_node(a);
49442 return nativeResponseValue;
49444 // struct LDKDestination Destination_blinded_path(struct LDKBlindedPath a);
49446 export function Destination_blinded_path(a: bigint): bigint {
49447 if(!isWasmInitialized) {
49448 throw new Error("initializeWasm() must be awaited first!");
49450 const nativeResponseValue = wasm.TS_Destination_blinded_path(a);
49451 return nativeResponseValue;
49453 // void SendError_free(struct LDKSendError this_ptr);
49455 export function SendError_free(this_ptr: bigint): void {
49456 if(!isWasmInitialized) {
49457 throw new Error("initializeWasm() must be awaited first!");
49459 const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
49460 // debug statements here
49462 // uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
49464 export function SendError_clone_ptr(arg: bigint): bigint {
49465 if(!isWasmInitialized) {
49466 throw new Error("initializeWasm() must be awaited first!");
49468 const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
49469 return nativeResponseValue;
49471 // struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
49473 export function SendError_clone(orig: bigint): bigint {
49474 if(!isWasmInitialized) {
49475 throw new Error("initializeWasm() must be awaited first!");
49477 const nativeResponseValue = wasm.TS_SendError_clone(orig);
49478 return nativeResponseValue;
49480 // struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
49482 export function SendError_secp256k1(a: Secp256k1Error): bigint {
49483 if(!isWasmInitialized) {
49484 throw new Error("initializeWasm() must be awaited first!");
49486 const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
49487 return nativeResponseValue;
49489 // struct LDKSendError SendError_too_big_packet(void);
49491 export function SendError_too_big_packet(): bigint {
49492 if(!isWasmInitialized) {
49493 throw new Error("initializeWasm() must be awaited first!");
49495 const nativeResponseValue = wasm.TS_SendError_too_big_packet();
49496 return nativeResponseValue;
49498 // struct LDKSendError SendError_too_few_blinded_hops(void);
49500 export function SendError_too_few_blinded_hops(): bigint {
49501 if(!isWasmInitialized) {
49502 throw new Error("initializeWasm() must be awaited first!");
49504 const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
49505 return nativeResponseValue;
49507 // struct LDKSendError SendError_invalid_first_hop(void);
49509 export function SendError_invalid_first_hop(): bigint {
49510 if(!isWasmInitialized) {
49511 throw new Error("initializeWasm() must be awaited first!");
49513 const nativeResponseValue = wasm.TS_SendError_invalid_first_hop();
49514 return nativeResponseValue;
49516 // struct LDKSendError SendError_invalid_message(void);
49518 export function SendError_invalid_message(): bigint {
49519 if(!isWasmInitialized) {
49520 throw new Error("initializeWasm() must be awaited first!");
49522 const nativeResponseValue = wasm.TS_SendError_invalid_message();
49523 return nativeResponseValue;
49525 // struct LDKSendError SendError_buffer_full(void);
49527 export function SendError_buffer_full(): bigint {
49528 if(!isWasmInitialized) {
49529 throw new Error("initializeWasm() must be awaited first!");
49531 const nativeResponseValue = wasm.TS_SendError_buffer_full();
49532 return nativeResponseValue;
49534 // struct LDKSendError SendError_get_node_id_failed(void);
49536 export function SendError_get_node_id_failed(): bigint {
49537 if(!isWasmInitialized) {
49538 throw new Error("initializeWasm() must be awaited first!");
49540 const nativeResponseValue = wasm.TS_SendError_get_node_id_failed();
49541 return nativeResponseValue;
49543 // struct LDKSendError SendError_blinded_path_advance_failed(void);
49545 export function SendError_blinded_path_advance_failed(): bigint {
49546 if(!isWasmInitialized) {
49547 throw new Error("initializeWasm() must be awaited first!");
49549 const nativeResponseValue = wasm.TS_SendError_blinded_path_advance_failed();
49550 return nativeResponseValue;
49552 // bool SendError_eq(const struct LDKSendError *NONNULL_PTR a, const struct LDKSendError *NONNULL_PTR b);
49554 export function SendError_eq(a: bigint, b: bigint): boolean {
49555 if(!isWasmInitialized) {
49556 throw new Error("initializeWasm() must be awaited first!");
49558 const nativeResponseValue = wasm.TS_SendError_eq(a, b);
49559 return nativeResponseValue;
49561 // void CustomOnionMessageHandler_free(struct LDKCustomOnionMessageHandler this_ptr);
49563 export function CustomOnionMessageHandler_free(this_ptr: bigint): void {
49564 if(!isWasmInitialized) {
49565 throw new Error("initializeWasm() must be awaited first!");
49567 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_free(this_ptr);
49568 // debug statements here
49570 // void PeeledOnion_free(struct LDKPeeledOnion this_ptr);
49572 export function PeeledOnion_free(this_ptr: bigint): void {
49573 if(!isWasmInitialized) {
49574 throw new Error("initializeWasm() must be awaited first!");
49576 const nativeResponseValue = wasm.TS_PeeledOnion_free(this_ptr);
49577 // debug statements here
49579 // uint64_t PeeledOnion_clone_ptr(LDKPeeledOnion *NONNULL_PTR arg);
49581 export function PeeledOnion_clone_ptr(arg: bigint): bigint {
49582 if(!isWasmInitialized) {
49583 throw new Error("initializeWasm() must be awaited first!");
49585 const nativeResponseValue = wasm.TS_PeeledOnion_clone_ptr(arg);
49586 return nativeResponseValue;
49588 // struct LDKPeeledOnion PeeledOnion_clone(const struct LDKPeeledOnion *NONNULL_PTR orig);
49590 export function PeeledOnion_clone(orig: bigint): bigint {
49591 if(!isWasmInitialized) {
49592 throw new Error("initializeWasm() must be awaited first!");
49594 const nativeResponseValue = wasm.TS_PeeledOnion_clone(orig);
49595 return nativeResponseValue;
49597 // struct LDKPeeledOnion PeeledOnion_forward(struct LDKPublicKey a, struct LDKOnionMessage b);
49599 export function PeeledOnion_forward(a: number, b: bigint): bigint {
49600 if(!isWasmInitialized) {
49601 throw new Error("initializeWasm() must be awaited first!");
49603 const nativeResponseValue = wasm.TS_PeeledOnion_forward(a, b);
49604 return nativeResponseValue;
49606 // struct LDKPeeledOnion PeeledOnion_receive(struct LDKParsedOnionMessageContents a, struct LDKThirtyTwoBytes b, struct LDKBlindedPath c);
49608 export function PeeledOnion_receive(a: bigint, b: number, c: bigint): bigint {
49609 if(!isWasmInitialized) {
49610 throw new Error("initializeWasm() must be awaited first!");
49612 const nativeResponseValue = wasm.TS_PeeledOnion_receive(a, b, c);
49613 return nativeResponseValue;
49615 // struct LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ create_onion_message(const struct LDKEntropySource *NONNULL_PTR entropy_source, const struct LDKNodeSigner *NONNULL_PTR node_signer, struct LDKOnionMessagePath path, struct LDKOnionMessageContents contents, struct LDKBlindedPath reply_path);
49617 export function create_onion_message(entropy_source: bigint, node_signer: bigint, path: bigint, contents: bigint, reply_path: bigint): bigint {
49618 if(!isWasmInitialized) {
49619 throw new Error("initializeWasm() must be awaited first!");
49621 const nativeResponseValue = wasm.TS_create_onion_message(entropy_source, node_signer, path, contents, reply_path);
49622 return nativeResponseValue;
49624 // struct LDKCResult_PeeledOnionNoneZ peel_onion_message(const struct LDKOnionMessage *NONNULL_PTR msg, struct LDKNodeSigner node_signer, struct LDKLogger logger, struct LDKCustomOnionMessageHandler custom_handler);
49626 export function peel_onion_message(msg: bigint, node_signer: bigint, logger: bigint, custom_handler: bigint): bigint {
49627 if(!isWasmInitialized) {
49628 throw new Error("initializeWasm() must be awaited first!");
49630 const nativeResponseValue = wasm.TS_peel_onion_message(msg, node_signer, logger, custom_handler);
49631 return nativeResponseValue;
49633 // MUST_USE_RES struct LDKOnionMessenger OnionMessenger_new(struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, struct LDKMessageRouter message_router, struct LDKOffersMessageHandler offers_handler, struct LDKCustomOnionMessageHandler custom_handler);
49635 export function OnionMessenger_new(entropy_source: bigint, node_signer: bigint, logger: bigint, message_router: bigint, offers_handler: bigint, custom_handler: bigint): bigint {
49636 if(!isWasmInitialized) {
49637 throw new Error("initializeWasm() must be awaited first!");
49639 const nativeResponseValue = wasm.TS_OnionMessenger_new(entropy_source, node_signer, logger, message_router, offers_handler, custom_handler);
49640 return nativeResponseValue;
49642 // MUST_USE_RES struct LDKCResult_NoneSendErrorZ OnionMessenger_send_onion_message(const struct LDKOnionMessenger *NONNULL_PTR this_arg, struct LDKOnionMessagePath path, struct LDKOnionMessageContents contents, struct LDKBlindedPath reply_path);
49644 export function OnionMessenger_send_onion_message(this_arg: bigint, path: bigint, contents: bigint, reply_path: bigint): bigint {
49645 if(!isWasmInitialized) {
49646 throw new Error("initializeWasm() must be awaited first!");
49648 const nativeResponseValue = wasm.TS_OnionMessenger_send_onion_message(this_arg, path, contents, reply_path);
49649 return nativeResponseValue;
49651 // struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
49653 export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
49654 if(!isWasmInitialized) {
49655 throw new Error("initializeWasm() must be awaited first!");
49657 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
49658 return nativeResponseValue;
49660 // void OffersMessageHandler_free(struct LDKOffersMessageHandler this_ptr);
49662 export function OffersMessageHandler_free(this_ptr: bigint): void {
49663 if(!isWasmInitialized) {
49664 throw new Error("initializeWasm() must be awaited first!");
49666 const nativeResponseValue = wasm.TS_OffersMessageHandler_free(this_ptr);
49667 // debug statements here
49669 // void OffersMessage_free(struct LDKOffersMessage this_ptr);
49671 export function OffersMessage_free(this_ptr: bigint): void {
49672 if(!isWasmInitialized) {
49673 throw new Error("initializeWasm() must be awaited first!");
49675 const nativeResponseValue = wasm.TS_OffersMessage_free(this_ptr);
49676 // debug statements here
49678 // uint64_t OffersMessage_clone_ptr(LDKOffersMessage *NONNULL_PTR arg);
49680 export function OffersMessage_clone_ptr(arg: bigint): bigint {
49681 if(!isWasmInitialized) {
49682 throw new Error("initializeWasm() must be awaited first!");
49684 const nativeResponseValue = wasm.TS_OffersMessage_clone_ptr(arg);
49685 return nativeResponseValue;
49687 // struct LDKOffersMessage OffersMessage_clone(const struct LDKOffersMessage *NONNULL_PTR orig);
49689 export function OffersMessage_clone(orig: bigint): bigint {
49690 if(!isWasmInitialized) {
49691 throw new Error("initializeWasm() must be awaited first!");
49693 const nativeResponseValue = wasm.TS_OffersMessage_clone(orig);
49694 return nativeResponseValue;
49696 // struct LDKOffersMessage OffersMessage_invoice_request(struct LDKInvoiceRequest a);
49698 export function OffersMessage_invoice_request(a: bigint): bigint {
49699 if(!isWasmInitialized) {
49700 throw new Error("initializeWasm() must be awaited first!");
49702 const nativeResponseValue = wasm.TS_OffersMessage_invoice_request(a);
49703 return nativeResponseValue;
49705 // struct LDKOffersMessage OffersMessage_invoice(struct LDKBolt12Invoice a);
49707 export function OffersMessage_invoice(a: bigint): bigint {
49708 if(!isWasmInitialized) {
49709 throw new Error("initializeWasm() must be awaited first!");
49711 const nativeResponseValue = wasm.TS_OffersMessage_invoice(a);
49712 return nativeResponseValue;
49714 // struct LDKOffersMessage OffersMessage_invoice_error(struct LDKInvoiceError a);
49716 export function OffersMessage_invoice_error(a: bigint): bigint {
49717 if(!isWasmInitialized) {
49718 throw new Error("initializeWasm() must be awaited first!");
49720 const nativeResponseValue = wasm.TS_OffersMessage_invoice_error(a);
49721 return nativeResponseValue;
49723 // MUST_USE_RES bool OffersMessage_is_known_type(uint64_t tlv_type);
49725 export function OffersMessage_is_known_type(tlv_type: bigint): boolean {
49726 if(!isWasmInitialized) {
49727 throw new Error("initializeWasm() must be awaited first!");
49729 const nativeResponseValue = wasm.TS_OffersMessage_is_known_type(tlv_type);
49730 return nativeResponseValue;
49732 // struct LDKCVec_u8Z OffersMessage_write(const struct LDKOffersMessage *NONNULL_PTR obj);
49734 export function OffersMessage_write(obj: bigint): number {
49735 if(!isWasmInitialized) {
49736 throw new Error("initializeWasm() must be awaited first!");
49738 const nativeResponseValue = wasm.TS_OffersMessage_write(obj);
49739 return nativeResponseValue;
49741 // struct LDKCResult_OffersMessageDecodeErrorZ OffersMessage_read(struct LDKu8slice ser, uint64_t arg_a, const struct LDKLogger *NONNULL_PTR arg_b);
49743 export function OffersMessage_read(ser: number, arg_a: bigint, arg_b: bigint): bigint {
49744 if(!isWasmInitialized) {
49745 throw new Error("initializeWasm() must be awaited first!");
49747 const nativeResponseValue = wasm.TS_OffersMessage_read(ser, arg_a, arg_b);
49748 return nativeResponseValue;
49750 // void Packet_free(struct LDKPacket this_obj);
49752 export function Packet_free(this_obj: bigint): void {
49753 if(!isWasmInitialized) {
49754 throw new Error("initializeWasm() must be awaited first!");
49756 const nativeResponseValue = wasm.TS_Packet_free(this_obj);
49757 // debug statements here
49759 // uint8_t Packet_get_version(const struct LDKPacket *NONNULL_PTR this_ptr);
49761 export function Packet_get_version(this_ptr: bigint): number {
49762 if(!isWasmInitialized) {
49763 throw new Error("initializeWasm() must be awaited first!");
49765 const nativeResponseValue = wasm.TS_Packet_get_version(this_ptr);
49766 return nativeResponseValue;
49768 // void Packet_set_version(struct LDKPacket *NONNULL_PTR this_ptr, uint8_t val);
49770 export function Packet_set_version(this_ptr: bigint, val: number): void {
49771 if(!isWasmInitialized) {
49772 throw new Error("initializeWasm() must be awaited first!");
49774 const nativeResponseValue = wasm.TS_Packet_set_version(this_ptr, val);
49775 // debug statements here
49777 // struct LDKPublicKey Packet_get_public_key(const struct LDKPacket *NONNULL_PTR this_ptr);
49779 export function Packet_get_public_key(this_ptr: bigint): number {
49780 if(!isWasmInitialized) {
49781 throw new Error("initializeWasm() must be awaited first!");
49783 const nativeResponseValue = wasm.TS_Packet_get_public_key(this_ptr);
49784 return nativeResponseValue;
49786 // void Packet_set_public_key(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKPublicKey val);
49788 export function Packet_set_public_key(this_ptr: bigint, val: number): void {
49789 if(!isWasmInitialized) {
49790 throw new Error("initializeWasm() must be awaited first!");
49792 const nativeResponseValue = wasm.TS_Packet_set_public_key(this_ptr, val);
49793 // debug statements here
49795 // struct LDKCVec_u8Z Packet_get_hop_data(const struct LDKPacket *NONNULL_PTR this_ptr);
49797 export function Packet_get_hop_data(this_ptr: bigint): number {
49798 if(!isWasmInitialized) {
49799 throw new Error("initializeWasm() must be awaited first!");
49801 const nativeResponseValue = wasm.TS_Packet_get_hop_data(this_ptr);
49802 return nativeResponseValue;
49804 // void Packet_set_hop_data(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
49806 export function Packet_set_hop_data(this_ptr: bigint, val: number): void {
49807 if(!isWasmInitialized) {
49808 throw new Error("initializeWasm() must be awaited first!");
49810 const nativeResponseValue = wasm.TS_Packet_set_hop_data(this_ptr, val);
49811 // debug statements here
49813 // const uint8_t (*Packet_get_hmac(const struct LDKPacket *NONNULL_PTR this_ptr))[32];
49815 export function Packet_get_hmac(this_ptr: bigint): number {
49816 if(!isWasmInitialized) {
49817 throw new Error("initializeWasm() must be awaited first!");
49819 const nativeResponseValue = wasm.TS_Packet_get_hmac(this_ptr);
49820 return nativeResponseValue;
49822 // void Packet_set_hmac(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
49824 export function Packet_set_hmac(this_ptr: bigint, val: number): void {
49825 if(!isWasmInitialized) {
49826 throw new Error("initializeWasm() must be awaited first!");
49828 const nativeResponseValue = wasm.TS_Packet_set_hmac(this_ptr, val);
49829 // debug statements here
49831 // 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);
49833 export function Packet_new(version_arg: number, public_key_arg: number, hop_data_arg: number, hmac_arg: number): bigint {
49834 if(!isWasmInitialized) {
49835 throw new Error("initializeWasm() must be awaited first!");
49837 const nativeResponseValue = wasm.TS_Packet_new(version_arg, public_key_arg, hop_data_arg, hmac_arg);
49838 return nativeResponseValue;
49840 // uint64_t Packet_clone_ptr(LDKPacket *NONNULL_PTR arg);
49842 export function Packet_clone_ptr(arg: bigint): bigint {
49843 if(!isWasmInitialized) {
49844 throw new Error("initializeWasm() must be awaited first!");
49846 const nativeResponseValue = wasm.TS_Packet_clone_ptr(arg);
49847 return nativeResponseValue;
49849 // struct LDKPacket Packet_clone(const struct LDKPacket *NONNULL_PTR orig);
49851 export function Packet_clone(orig: bigint): bigint {
49852 if(!isWasmInitialized) {
49853 throw new Error("initializeWasm() must be awaited first!");
49855 const nativeResponseValue = wasm.TS_Packet_clone(orig);
49856 return nativeResponseValue;
49858 // bool Packet_eq(const struct LDKPacket *NONNULL_PTR a, const struct LDKPacket *NONNULL_PTR b);
49860 export function Packet_eq(a: bigint, b: bigint): boolean {
49861 if(!isWasmInitialized) {
49862 throw new Error("initializeWasm() must be awaited first!");
49864 const nativeResponseValue = wasm.TS_Packet_eq(a, b);
49865 return nativeResponseValue;
49867 // struct LDKCVec_u8Z Packet_write(const struct LDKPacket *NONNULL_PTR obj);
49869 export function Packet_write(obj: bigint): number {
49870 if(!isWasmInitialized) {
49871 throw new Error("initializeWasm() must be awaited first!");
49873 const nativeResponseValue = wasm.TS_Packet_write(obj);
49874 return nativeResponseValue;
49876 // void ParsedOnionMessageContents_free(struct LDKParsedOnionMessageContents this_ptr);
49878 export function ParsedOnionMessageContents_free(this_ptr: bigint): void {
49879 if(!isWasmInitialized) {
49880 throw new Error("initializeWasm() must be awaited first!");
49882 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_free(this_ptr);
49883 // debug statements here
49885 // uint64_t ParsedOnionMessageContents_clone_ptr(LDKParsedOnionMessageContents *NONNULL_PTR arg);
49887 export function ParsedOnionMessageContents_clone_ptr(arg: bigint): bigint {
49888 if(!isWasmInitialized) {
49889 throw new Error("initializeWasm() must be awaited first!");
49891 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_clone_ptr(arg);
49892 return nativeResponseValue;
49894 // struct LDKParsedOnionMessageContents ParsedOnionMessageContents_clone(const struct LDKParsedOnionMessageContents *NONNULL_PTR orig);
49896 export function ParsedOnionMessageContents_clone(orig: bigint): bigint {
49897 if(!isWasmInitialized) {
49898 throw new Error("initializeWasm() must be awaited first!");
49900 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_clone(orig);
49901 return nativeResponseValue;
49903 // struct LDKParsedOnionMessageContents ParsedOnionMessageContents_offers(struct LDKOffersMessage a);
49905 export function ParsedOnionMessageContents_offers(a: bigint): bigint {
49906 if(!isWasmInitialized) {
49907 throw new Error("initializeWasm() must be awaited first!");
49909 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_offers(a);
49910 return nativeResponseValue;
49912 // struct LDKParsedOnionMessageContents ParsedOnionMessageContents_custom(struct LDKOnionMessageContents a);
49914 export function ParsedOnionMessageContents_custom(a: bigint): bigint {
49915 if(!isWasmInitialized) {
49916 throw new Error("initializeWasm() must be awaited first!");
49918 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_custom(a);
49919 return nativeResponseValue;
49921 // struct LDKOnionMessageContents ParsedOnionMessageContents_as_OnionMessageContents(const struct LDKParsedOnionMessageContents *NONNULL_PTR this_arg);
49923 export function ParsedOnionMessageContents_as_OnionMessageContents(this_arg: bigint): bigint {
49924 if(!isWasmInitialized) {
49925 throw new Error("initializeWasm() must be awaited first!");
49927 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_as_OnionMessageContents(this_arg);
49928 return nativeResponseValue;
49930 // struct LDKCVec_u8Z ParsedOnionMessageContents_write(const struct LDKParsedOnionMessageContents *NONNULL_PTR obj);
49932 export function ParsedOnionMessageContents_write(obj: bigint): number {
49933 if(!isWasmInitialized) {
49934 throw new Error("initializeWasm() must be awaited first!");
49936 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_write(obj);
49937 return nativeResponseValue;
49939 // uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg);
49941 export function OnionMessageContents_clone_ptr(arg: bigint): bigint {
49942 if(!isWasmInitialized) {
49943 throw new Error("initializeWasm() must be awaited first!");
49945 const nativeResponseValue = wasm.TS_OnionMessageContents_clone_ptr(arg);
49946 return nativeResponseValue;
49948 // struct LDKOnionMessageContents OnionMessageContents_clone(const struct LDKOnionMessageContents *NONNULL_PTR orig);
49950 export function OnionMessageContents_clone(orig: bigint): bigint {
49951 if(!isWasmInitialized) {
49952 throw new Error("initializeWasm() must be awaited first!");
49954 const nativeResponseValue = wasm.TS_OnionMessageContents_clone(orig);
49955 return nativeResponseValue;
49957 // void OnionMessageContents_free(struct LDKOnionMessageContents this_ptr);
49959 export function OnionMessageContents_free(this_ptr: bigint): void {
49960 if(!isWasmInitialized) {
49961 throw new Error("initializeWasm() must be awaited first!");
49963 const nativeResponseValue = wasm.TS_OnionMessageContents_free(this_ptr);
49964 // debug statements here
49966 // void BlindedPath_free(struct LDKBlindedPath this_obj);
49968 export function BlindedPath_free(this_obj: bigint): void {
49969 if(!isWasmInitialized) {
49970 throw new Error("initializeWasm() must be awaited first!");
49972 const nativeResponseValue = wasm.TS_BlindedPath_free(this_obj);
49973 // debug statements here
49975 // struct LDKPublicKey BlindedPath_get_introduction_node_id(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
49977 export function BlindedPath_get_introduction_node_id(this_ptr: bigint): number {
49978 if(!isWasmInitialized) {
49979 throw new Error("initializeWasm() must be awaited first!");
49981 const nativeResponseValue = wasm.TS_BlindedPath_get_introduction_node_id(this_ptr);
49982 return nativeResponseValue;
49984 // void BlindedPath_set_introduction_node_id(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKPublicKey val);
49986 export function BlindedPath_set_introduction_node_id(this_ptr: bigint, val: number): void {
49987 if(!isWasmInitialized) {
49988 throw new Error("initializeWasm() must be awaited first!");
49990 const nativeResponseValue = wasm.TS_BlindedPath_set_introduction_node_id(this_ptr, val);
49991 // debug statements here
49993 // struct LDKPublicKey BlindedPath_get_blinding_point(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
49995 export function BlindedPath_get_blinding_point(this_ptr: bigint): number {
49996 if(!isWasmInitialized) {
49997 throw new Error("initializeWasm() must be awaited first!");
49999 const nativeResponseValue = wasm.TS_BlindedPath_get_blinding_point(this_ptr);
50000 return nativeResponseValue;
50002 // void BlindedPath_set_blinding_point(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKPublicKey val);
50004 export function BlindedPath_set_blinding_point(this_ptr: bigint, val: number): void {
50005 if(!isWasmInitialized) {
50006 throw new Error("initializeWasm() must be awaited first!");
50008 const nativeResponseValue = wasm.TS_BlindedPath_set_blinding_point(this_ptr, val);
50009 // debug statements here
50011 // struct LDKCVec_BlindedHopZ BlindedPath_get_blinded_hops(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
50013 export function BlindedPath_get_blinded_hops(this_ptr: bigint): number {
50014 if(!isWasmInitialized) {
50015 throw new Error("initializeWasm() must be awaited first!");
50017 const nativeResponseValue = wasm.TS_BlindedPath_get_blinded_hops(this_ptr);
50018 return nativeResponseValue;
50020 // void BlindedPath_set_blinded_hops(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKCVec_BlindedHopZ val);
50022 export function BlindedPath_set_blinded_hops(this_ptr: bigint, val: number): void {
50023 if(!isWasmInitialized) {
50024 throw new Error("initializeWasm() must be awaited first!");
50026 const nativeResponseValue = wasm.TS_BlindedPath_set_blinded_hops(this_ptr, val);
50027 // debug statements here
50029 // MUST_USE_RES struct LDKBlindedPath BlindedPath_new(struct LDKPublicKey introduction_node_id_arg, struct LDKPublicKey blinding_point_arg, struct LDKCVec_BlindedHopZ blinded_hops_arg);
50031 export function BlindedPath_new(introduction_node_id_arg: number, blinding_point_arg: number, blinded_hops_arg: number): bigint {
50032 if(!isWasmInitialized) {
50033 throw new Error("initializeWasm() must be awaited first!");
50035 const nativeResponseValue = wasm.TS_BlindedPath_new(introduction_node_id_arg, blinding_point_arg, blinded_hops_arg);
50036 return nativeResponseValue;
50038 // uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg);
50040 export function BlindedPath_clone_ptr(arg: bigint): bigint {
50041 if(!isWasmInitialized) {
50042 throw new Error("initializeWasm() must be awaited first!");
50044 const nativeResponseValue = wasm.TS_BlindedPath_clone_ptr(arg);
50045 return nativeResponseValue;
50047 // struct LDKBlindedPath BlindedPath_clone(const struct LDKBlindedPath *NONNULL_PTR orig);
50049 export function BlindedPath_clone(orig: bigint): bigint {
50050 if(!isWasmInitialized) {
50051 throw new Error("initializeWasm() must be awaited first!");
50053 const nativeResponseValue = wasm.TS_BlindedPath_clone(orig);
50054 return nativeResponseValue;
50056 // uint64_t BlindedPath_hash(const struct LDKBlindedPath *NONNULL_PTR o);
50058 export function BlindedPath_hash(o: bigint): bigint {
50059 if(!isWasmInitialized) {
50060 throw new Error("initializeWasm() must be awaited first!");
50062 const nativeResponseValue = wasm.TS_BlindedPath_hash(o);
50063 return nativeResponseValue;
50065 // bool BlindedPath_eq(const struct LDKBlindedPath *NONNULL_PTR a, const struct LDKBlindedPath *NONNULL_PTR b);
50067 export function BlindedPath_eq(a: bigint, b: bigint): boolean {
50068 if(!isWasmInitialized) {
50069 throw new Error("initializeWasm() must be awaited first!");
50071 const nativeResponseValue = wasm.TS_BlindedPath_eq(a, b);
50072 return nativeResponseValue;
50074 // void BlindedHop_free(struct LDKBlindedHop this_obj);
50076 export function BlindedHop_free(this_obj: bigint): void {
50077 if(!isWasmInitialized) {
50078 throw new Error("initializeWasm() must be awaited first!");
50080 const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
50081 // debug statements here
50083 // struct LDKPublicKey BlindedHop_get_blinded_node_id(const struct LDKBlindedHop *NONNULL_PTR this_ptr);
50085 export function BlindedHop_get_blinded_node_id(this_ptr: bigint): number {
50086 if(!isWasmInitialized) {
50087 throw new Error("initializeWasm() must be awaited first!");
50089 const nativeResponseValue = wasm.TS_BlindedHop_get_blinded_node_id(this_ptr);
50090 return nativeResponseValue;
50092 // void BlindedHop_set_blinded_node_id(struct LDKBlindedHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
50094 export function BlindedHop_set_blinded_node_id(this_ptr: bigint, val: number): void {
50095 if(!isWasmInitialized) {
50096 throw new Error("initializeWasm() must be awaited first!");
50098 const nativeResponseValue = wasm.TS_BlindedHop_set_blinded_node_id(this_ptr, val);
50099 // debug statements here
50101 // struct LDKCVec_u8Z BlindedHop_get_encrypted_payload(const struct LDKBlindedHop *NONNULL_PTR this_ptr);
50103 export function BlindedHop_get_encrypted_payload(this_ptr: bigint): number {
50104 if(!isWasmInitialized) {
50105 throw new Error("initializeWasm() must be awaited first!");
50107 const nativeResponseValue = wasm.TS_BlindedHop_get_encrypted_payload(this_ptr);
50108 return nativeResponseValue;
50110 // void BlindedHop_set_encrypted_payload(struct LDKBlindedHop *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
50112 export function BlindedHop_set_encrypted_payload(this_ptr: bigint, val: number): void {
50113 if(!isWasmInitialized) {
50114 throw new Error("initializeWasm() must be awaited first!");
50116 const nativeResponseValue = wasm.TS_BlindedHop_set_encrypted_payload(this_ptr, val);
50117 // debug statements here
50119 // MUST_USE_RES struct LDKBlindedHop BlindedHop_new(struct LDKPublicKey blinded_node_id_arg, struct LDKCVec_u8Z encrypted_payload_arg);
50121 export function BlindedHop_new(blinded_node_id_arg: number, encrypted_payload_arg: number): bigint {
50122 if(!isWasmInitialized) {
50123 throw new Error("initializeWasm() must be awaited first!");
50125 const nativeResponseValue = wasm.TS_BlindedHop_new(blinded_node_id_arg, encrypted_payload_arg);
50126 return nativeResponseValue;
50128 // uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg);
50130 export function BlindedHop_clone_ptr(arg: bigint): bigint {
50131 if(!isWasmInitialized) {
50132 throw new Error("initializeWasm() must be awaited first!");
50134 const nativeResponseValue = wasm.TS_BlindedHop_clone_ptr(arg);
50135 return nativeResponseValue;
50137 // struct LDKBlindedHop BlindedHop_clone(const struct LDKBlindedHop *NONNULL_PTR orig);
50139 export function BlindedHop_clone(orig: bigint): bigint {
50140 if(!isWasmInitialized) {
50141 throw new Error("initializeWasm() must be awaited first!");
50143 const nativeResponseValue = wasm.TS_BlindedHop_clone(orig);
50144 return nativeResponseValue;
50146 // uint64_t BlindedHop_hash(const struct LDKBlindedHop *NONNULL_PTR o);
50148 export function BlindedHop_hash(o: bigint): bigint {
50149 if(!isWasmInitialized) {
50150 throw new Error("initializeWasm() must be awaited first!");
50152 const nativeResponseValue = wasm.TS_BlindedHop_hash(o);
50153 return nativeResponseValue;
50155 // bool BlindedHop_eq(const struct LDKBlindedHop *NONNULL_PTR a, const struct LDKBlindedHop *NONNULL_PTR b);
50157 export function BlindedHop_eq(a: bigint, b: bigint): boolean {
50158 if(!isWasmInitialized) {
50159 throw new Error("initializeWasm() must be awaited first!");
50161 const nativeResponseValue = wasm.TS_BlindedHop_eq(a, b);
50162 return nativeResponseValue;
50164 // MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_one_hop_for_message(struct LDKPublicKey recipient_node_id, const struct LDKEntropySource *NONNULL_PTR entropy_source);
50166 export function BlindedPath_one_hop_for_message(recipient_node_id: number, entropy_source: bigint): bigint {
50167 if(!isWasmInitialized) {
50168 throw new Error("initializeWasm() must be awaited first!");
50170 const nativeResponseValue = wasm.TS_BlindedPath_one_hop_for_message(recipient_node_id, entropy_source);
50171 return nativeResponseValue;
50173 // MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_new_for_message(struct LDKCVec_PublicKeyZ node_pks, const struct LDKEntropySource *NONNULL_PTR entropy_source);
50175 export function BlindedPath_new_for_message(node_pks: number, entropy_source: bigint): bigint {
50176 if(!isWasmInitialized) {
50177 throw new Error("initializeWasm() must be awaited first!");
50179 const nativeResponseValue = wasm.TS_BlindedPath_new_for_message(node_pks, entropy_source);
50180 return nativeResponseValue;
50182 // MUST_USE_RES struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ BlindedPath_one_hop_for_payment(struct LDKPublicKey payee_node_id, struct LDKReceiveTlvs payee_tlvs, const struct LDKEntropySource *NONNULL_PTR entropy_source);
50184 export function BlindedPath_one_hop_for_payment(payee_node_id: number, payee_tlvs: bigint, entropy_source: bigint): bigint {
50185 if(!isWasmInitialized) {
50186 throw new Error("initializeWasm() must be awaited first!");
50188 const nativeResponseValue = wasm.TS_BlindedPath_one_hop_for_payment(payee_node_id, payee_tlvs, entropy_source);
50189 return nativeResponseValue;
50191 // struct LDKCVec_u8Z BlindedPath_write(const struct LDKBlindedPath *NONNULL_PTR obj);
50193 export function BlindedPath_write(obj: bigint): number {
50194 if(!isWasmInitialized) {
50195 throw new Error("initializeWasm() must be awaited first!");
50197 const nativeResponseValue = wasm.TS_BlindedPath_write(obj);
50198 return nativeResponseValue;
50200 // struct LDKCResult_BlindedPathDecodeErrorZ BlindedPath_read(struct LDKu8slice ser);
50202 export function BlindedPath_read(ser: number): bigint {
50203 if(!isWasmInitialized) {
50204 throw new Error("initializeWasm() must be awaited first!");
50206 const nativeResponseValue = wasm.TS_BlindedPath_read(ser);
50207 return nativeResponseValue;
50209 // struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
50211 export function BlindedHop_write(obj: bigint): number {
50212 if(!isWasmInitialized) {
50213 throw new Error("initializeWasm() must be awaited first!");
50215 const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
50216 return nativeResponseValue;
50218 // struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
50220 export function BlindedHop_read(ser: number): bigint {
50221 if(!isWasmInitialized) {
50222 throw new Error("initializeWasm() must be awaited first!");
50224 const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
50225 return nativeResponseValue;
50227 // void ForwardNode_free(struct LDKForwardNode this_obj);
50229 export function ForwardNode_free(this_obj: bigint): void {
50230 if(!isWasmInitialized) {
50231 throw new Error("initializeWasm() must be awaited first!");
50233 const nativeResponseValue = wasm.TS_ForwardNode_free(this_obj);
50234 // debug statements here
50236 // struct LDKForwardTlvs ForwardNode_get_tlvs(const struct LDKForwardNode *NONNULL_PTR this_ptr);
50238 export function ForwardNode_get_tlvs(this_ptr: bigint): bigint {
50239 if(!isWasmInitialized) {
50240 throw new Error("initializeWasm() must be awaited first!");
50242 const nativeResponseValue = wasm.TS_ForwardNode_get_tlvs(this_ptr);
50243 return nativeResponseValue;
50245 // void ForwardNode_set_tlvs(struct LDKForwardNode *NONNULL_PTR this_ptr, struct LDKForwardTlvs val);
50247 export function ForwardNode_set_tlvs(this_ptr: bigint, val: bigint): void {
50248 if(!isWasmInitialized) {
50249 throw new Error("initializeWasm() must be awaited first!");
50251 const nativeResponseValue = wasm.TS_ForwardNode_set_tlvs(this_ptr, val);
50252 // debug statements here
50254 // struct LDKPublicKey ForwardNode_get_node_id(const struct LDKForwardNode *NONNULL_PTR this_ptr);
50256 export function ForwardNode_get_node_id(this_ptr: bigint): number {
50257 if(!isWasmInitialized) {
50258 throw new Error("initializeWasm() must be awaited first!");
50260 const nativeResponseValue = wasm.TS_ForwardNode_get_node_id(this_ptr);
50261 return nativeResponseValue;
50263 // void ForwardNode_set_node_id(struct LDKForwardNode *NONNULL_PTR this_ptr, struct LDKPublicKey val);
50265 export function ForwardNode_set_node_id(this_ptr: bigint, val: number): void {
50266 if(!isWasmInitialized) {
50267 throw new Error("initializeWasm() must be awaited first!");
50269 const nativeResponseValue = wasm.TS_ForwardNode_set_node_id(this_ptr, val);
50270 // debug statements here
50272 // uint64_t ForwardNode_get_htlc_maximum_msat(const struct LDKForwardNode *NONNULL_PTR this_ptr);
50274 export function ForwardNode_get_htlc_maximum_msat(this_ptr: bigint): bigint {
50275 if(!isWasmInitialized) {
50276 throw new Error("initializeWasm() must be awaited first!");
50278 const nativeResponseValue = wasm.TS_ForwardNode_get_htlc_maximum_msat(this_ptr);
50279 return nativeResponseValue;
50281 // void ForwardNode_set_htlc_maximum_msat(struct LDKForwardNode *NONNULL_PTR this_ptr, uint64_t val);
50283 export function ForwardNode_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
50284 if(!isWasmInitialized) {
50285 throw new Error("initializeWasm() must be awaited first!");
50287 const nativeResponseValue = wasm.TS_ForwardNode_set_htlc_maximum_msat(this_ptr, val);
50288 // debug statements here
50290 // MUST_USE_RES struct LDKForwardNode ForwardNode_new(struct LDKForwardTlvs tlvs_arg, struct LDKPublicKey node_id_arg, uint64_t htlc_maximum_msat_arg);
50292 export function ForwardNode_new(tlvs_arg: bigint, node_id_arg: number, htlc_maximum_msat_arg: bigint): bigint {
50293 if(!isWasmInitialized) {
50294 throw new Error("initializeWasm() must be awaited first!");
50296 const nativeResponseValue = wasm.TS_ForwardNode_new(tlvs_arg, node_id_arg, htlc_maximum_msat_arg);
50297 return nativeResponseValue;
50299 // uint64_t ForwardNode_clone_ptr(LDKForwardNode *NONNULL_PTR arg);
50301 export function ForwardNode_clone_ptr(arg: bigint): bigint {
50302 if(!isWasmInitialized) {
50303 throw new Error("initializeWasm() must be awaited first!");
50305 const nativeResponseValue = wasm.TS_ForwardNode_clone_ptr(arg);
50306 return nativeResponseValue;
50308 // struct LDKForwardNode ForwardNode_clone(const struct LDKForwardNode *NONNULL_PTR orig);
50310 export function ForwardNode_clone(orig: bigint): bigint {
50311 if(!isWasmInitialized) {
50312 throw new Error("initializeWasm() must be awaited first!");
50314 const nativeResponseValue = wasm.TS_ForwardNode_clone(orig);
50315 return nativeResponseValue;
50317 // void ForwardTlvs_free(struct LDKForwardTlvs this_obj);
50319 export function ForwardTlvs_free(this_obj: bigint): void {
50320 if(!isWasmInitialized) {
50321 throw new Error("initializeWasm() must be awaited first!");
50323 const nativeResponseValue = wasm.TS_ForwardTlvs_free(this_obj);
50324 // debug statements here
50326 // uint64_t ForwardTlvs_get_short_channel_id(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
50328 export function ForwardTlvs_get_short_channel_id(this_ptr: bigint): bigint {
50329 if(!isWasmInitialized) {
50330 throw new Error("initializeWasm() must be awaited first!");
50332 const nativeResponseValue = wasm.TS_ForwardTlvs_get_short_channel_id(this_ptr);
50333 return nativeResponseValue;
50335 // void ForwardTlvs_set_short_channel_id(struct LDKForwardTlvs *NONNULL_PTR this_ptr, uint64_t val);
50337 export function ForwardTlvs_set_short_channel_id(this_ptr: bigint, val: bigint): void {
50338 if(!isWasmInitialized) {
50339 throw new Error("initializeWasm() must be awaited first!");
50341 const nativeResponseValue = wasm.TS_ForwardTlvs_set_short_channel_id(this_ptr, val);
50342 // debug statements here
50344 // struct LDKPaymentRelay ForwardTlvs_get_payment_relay(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
50346 export function ForwardTlvs_get_payment_relay(this_ptr: bigint): bigint {
50347 if(!isWasmInitialized) {
50348 throw new Error("initializeWasm() must be awaited first!");
50350 const nativeResponseValue = wasm.TS_ForwardTlvs_get_payment_relay(this_ptr);
50351 return nativeResponseValue;
50353 // void ForwardTlvs_set_payment_relay(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKPaymentRelay val);
50355 export function ForwardTlvs_set_payment_relay(this_ptr: bigint, val: bigint): void {
50356 if(!isWasmInitialized) {
50357 throw new Error("initializeWasm() must be awaited first!");
50359 const nativeResponseValue = wasm.TS_ForwardTlvs_set_payment_relay(this_ptr, val);
50360 // debug statements here
50362 // struct LDKPaymentConstraints ForwardTlvs_get_payment_constraints(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
50364 export function ForwardTlvs_get_payment_constraints(this_ptr: bigint): bigint {
50365 if(!isWasmInitialized) {
50366 throw new Error("initializeWasm() must be awaited first!");
50368 const nativeResponseValue = wasm.TS_ForwardTlvs_get_payment_constraints(this_ptr);
50369 return nativeResponseValue;
50371 // void ForwardTlvs_set_payment_constraints(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKPaymentConstraints val);
50373 export function ForwardTlvs_set_payment_constraints(this_ptr: bigint, val: bigint): void {
50374 if(!isWasmInitialized) {
50375 throw new Error("initializeWasm() must be awaited first!");
50377 const nativeResponseValue = wasm.TS_ForwardTlvs_set_payment_constraints(this_ptr, val);
50378 // debug statements here
50380 // struct LDKBlindedHopFeatures ForwardTlvs_get_features(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
50382 export function ForwardTlvs_get_features(this_ptr: bigint): bigint {
50383 if(!isWasmInitialized) {
50384 throw new Error("initializeWasm() must be awaited first!");
50386 const nativeResponseValue = wasm.TS_ForwardTlvs_get_features(this_ptr);
50387 return nativeResponseValue;
50389 // void ForwardTlvs_set_features(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKBlindedHopFeatures val);
50391 export function ForwardTlvs_set_features(this_ptr: bigint, val: bigint): void {
50392 if(!isWasmInitialized) {
50393 throw new Error("initializeWasm() must be awaited first!");
50395 const nativeResponseValue = wasm.TS_ForwardTlvs_set_features(this_ptr, val);
50396 // debug statements here
50398 // 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);
50400 export function ForwardTlvs_new(short_channel_id_arg: bigint, payment_relay_arg: bigint, payment_constraints_arg: bigint, features_arg: bigint): bigint {
50401 if(!isWasmInitialized) {
50402 throw new Error("initializeWasm() must be awaited first!");
50404 const nativeResponseValue = wasm.TS_ForwardTlvs_new(short_channel_id_arg, payment_relay_arg, payment_constraints_arg, features_arg);
50405 return nativeResponseValue;
50407 // uint64_t ForwardTlvs_clone_ptr(LDKForwardTlvs *NONNULL_PTR arg);
50409 export function ForwardTlvs_clone_ptr(arg: bigint): bigint {
50410 if(!isWasmInitialized) {
50411 throw new Error("initializeWasm() must be awaited first!");
50413 const nativeResponseValue = wasm.TS_ForwardTlvs_clone_ptr(arg);
50414 return nativeResponseValue;
50416 // struct LDKForwardTlvs ForwardTlvs_clone(const struct LDKForwardTlvs *NONNULL_PTR orig);
50418 export function ForwardTlvs_clone(orig: bigint): bigint {
50419 if(!isWasmInitialized) {
50420 throw new Error("initializeWasm() must be awaited first!");
50422 const nativeResponseValue = wasm.TS_ForwardTlvs_clone(orig);
50423 return nativeResponseValue;
50425 // void ReceiveTlvs_free(struct LDKReceiveTlvs this_obj);
50427 export function ReceiveTlvs_free(this_obj: bigint): void {
50428 if(!isWasmInitialized) {
50429 throw new Error("initializeWasm() must be awaited first!");
50431 const nativeResponseValue = wasm.TS_ReceiveTlvs_free(this_obj);
50432 // debug statements here
50434 // const uint8_t (*ReceiveTlvs_get_payment_secret(const struct LDKReceiveTlvs *NONNULL_PTR this_ptr))[32];
50436 export function ReceiveTlvs_get_payment_secret(this_ptr: bigint): number {
50437 if(!isWasmInitialized) {
50438 throw new Error("initializeWasm() must be awaited first!");
50440 const nativeResponseValue = wasm.TS_ReceiveTlvs_get_payment_secret(this_ptr);
50441 return nativeResponseValue;
50443 // void ReceiveTlvs_set_payment_secret(struct LDKReceiveTlvs *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
50445 export function ReceiveTlvs_set_payment_secret(this_ptr: bigint, val: number): void {
50446 if(!isWasmInitialized) {
50447 throw new Error("initializeWasm() must be awaited first!");
50449 const nativeResponseValue = wasm.TS_ReceiveTlvs_set_payment_secret(this_ptr, val);
50450 // debug statements here
50452 // struct LDKPaymentConstraints ReceiveTlvs_get_payment_constraints(const struct LDKReceiveTlvs *NONNULL_PTR this_ptr);
50454 export function ReceiveTlvs_get_payment_constraints(this_ptr: bigint): bigint {
50455 if(!isWasmInitialized) {
50456 throw new Error("initializeWasm() must be awaited first!");
50458 const nativeResponseValue = wasm.TS_ReceiveTlvs_get_payment_constraints(this_ptr);
50459 return nativeResponseValue;
50461 // void ReceiveTlvs_set_payment_constraints(struct LDKReceiveTlvs *NONNULL_PTR this_ptr, struct LDKPaymentConstraints val);
50463 export function ReceiveTlvs_set_payment_constraints(this_ptr: bigint, val: bigint): void {
50464 if(!isWasmInitialized) {
50465 throw new Error("initializeWasm() must be awaited first!");
50467 const nativeResponseValue = wasm.TS_ReceiveTlvs_set_payment_constraints(this_ptr, val);
50468 // debug statements here
50470 // MUST_USE_RES struct LDKReceiveTlvs ReceiveTlvs_new(struct LDKThirtyTwoBytes payment_secret_arg, struct LDKPaymentConstraints payment_constraints_arg);
50472 export function ReceiveTlvs_new(payment_secret_arg: number, payment_constraints_arg: bigint): bigint {
50473 if(!isWasmInitialized) {
50474 throw new Error("initializeWasm() must be awaited first!");
50476 const nativeResponseValue = wasm.TS_ReceiveTlvs_new(payment_secret_arg, payment_constraints_arg);
50477 return nativeResponseValue;
50479 // uint64_t ReceiveTlvs_clone_ptr(LDKReceiveTlvs *NONNULL_PTR arg);
50481 export function ReceiveTlvs_clone_ptr(arg: bigint): bigint {
50482 if(!isWasmInitialized) {
50483 throw new Error("initializeWasm() must be awaited first!");
50485 const nativeResponseValue = wasm.TS_ReceiveTlvs_clone_ptr(arg);
50486 return nativeResponseValue;
50488 // struct LDKReceiveTlvs ReceiveTlvs_clone(const struct LDKReceiveTlvs *NONNULL_PTR orig);
50490 export function ReceiveTlvs_clone(orig: bigint): bigint {
50491 if(!isWasmInitialized) {
50492 throw new Error("initializeWasm() must be awaited first!");
50494 const nativeResponseValue = wasm.TS_ReceiveTlvs_clone(orig);
50495 return nativeResponseValue;
50497 // void PaymentRelay_free(struct LDKPaymentRelay this_obj);
50499 export function PaymentRelay_free(this_obj: bigint): void {
50500 if(!isWasmInitialized) {
50501 throw new Error("initializeWasm() must be awaited first!");
50503 const nativeResponseValue = wasm.TS_PaymentRelay_free(this_obj);
50504 // debug statements here
50506 // uint16_t PaymentRelay_get_cltv_expiry_delta(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
50508 export function PaymentRelay_get_cltv_expiry_delta(this_ptr: bigint): number {
50509 if(!isWasmInitialized) {
50510 throw new Error("initializeWasm() must be awaited first!");
50512 const nativeResponseValue = wasm.TS_PaymentRelay_get_cltv_expiry_delta(this_ptr);
50513 return nativeResponseValue;
50515 // void PaymentRelay_set_cltv_expiry_delta(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint16_t val);
50517 export function PaymentRelay_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
50518 if(!isWasmInitialized) {
50519 throw new Error("initializeWasm() must be awaited first!");
50521 const nativeResponseValue = wasm.TS_PaymentRelay_set_cltv_expiry_delta(this_ptr, val);
50522 // debug statements here
50524 // uint32_t PaymentRelay_get_fee_proportional_millionths(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
50526 export function PaymentRelay_get_fee_proportional_millionths(this_ptr: bigint): number {
50527 if(!isWasmInitialized) {
50528 throw new Error("initializeWasm() must be awaited first!");
50530 const nativeResponseValue = wasm.TS_PaymentRelay_get_fee_proportional_millionths(this_ptr);
50531 return nativeResponseValue;
50533 // void PaymentRelay_set_fee_proportional_millionths(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint32_t val);
50535 export function PaymentRelay_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
50536 if(!isWasmInitialized) {
50537 throw new Error("initializeWasm() must be awaited first!");
50539 const nativeResponseValue = wasm.TS_PaymentRelay_set_fee_proportional_millionths(this_ptr, val);
50540 // debug statements here
50542 // uint32_t PaymentRelay_get_fee_base_msat(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
50544 export function PaymentRelay_get_fee_base_msat(this_ptr: bigint): number {
50545 if(!isWasmInitialized) {
50546 throw new Error("initializeWasm() must be awaited first!");
50548 const nativeResponseValue = wasm.TS_PaymentRelay_get_fee_base_msat(this_ptr);
50549 return nativeResponseValue;
50551 // void PaymentRelay_set_fee_base_msat(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint32_t val);
50553 export function PaymentRelay_set_fee_base_msat(this_ptr: bigint, val: number): void {
50554 if(!isWasmInitialized) {
50555 throw new Error("initializeWasm() must be awaited first!");
50557 const nativeResponseValue = wasm.TS_PaymentRelay_set_fee_base_msat(this_ptr, val);
50558 // debug statements here
50560 // 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);
50562 export function PaymentRelay_new(cltv_expiry_delta_arg: number, fee_proportional_millionths_arg: number, fee_base_msat_arg: number): bigint {
50563 if(!isWasmInitialized) {
50564 throw new Error("initializeWasm() must be awaited first!");
50566 const nativeResponseValue = wasm.TS_PaymentRelay_new(cltv_expiry_delta_arg, fee_proportional_millionths_arg, fee_base_msat_arg);
50567 return nativeResponseValue;
50569 // uint64_t PaymentRelay_clone_ptr(LDKPaymentRelay *NONNULL_PTR arg);
50571 export function PaymentRelay_clone_ptr(arg: bigint): bigint {
50572 if(!isWasmInitialized) {
50573 throw new Error("initializeWasm() must be awaited first!");
50575 const nativeResponseValue = wasm.TS_PaymentRelay_clone_ptr(arg);
50576 return nativeResponseValue;
50578 // struct LDKPaymentRelay PaymentRelay_clone(const struct LDKPaymentRelay *NONNULL_PTR orig);
50580 export function PaymentRelay_clone(orig: bigint): bigint {
50581 if(!isWasmInitialized) {
50582 throw new Error("initializeWasm() must be awaited first!");
50584 const nativeResponseValue = wasm.TS_PaymentRelay_clone(orig);
50585 return nativeResponseValue;
50587 // void PaymentConstraints_free(struct LDKPaymentConstraints this_obj);
50589 export function PaymentConstraints_free(this_obj: bigint): void {
50590 if(!isWasmInitialized) {
50591 throw new Error("initializeWasm() must be awaited first!");
50593 const nativeResponseValue = wasm.TS_PaymentConstraints_free(this_obj);
50594 // debug statements here
50596 // uint32_t PaymentConstraints_get_max_cltv_expiry(const struct LDKPaymentConstraints *NONNULL_PTR this_ptr);
50598 export function PaymentConstraints_get_max_cltv_expiry(this_ptr: bigint): number {
50599 if(!isWasmInitialized) {
50600 throw new Error("initializeWasm() must be awaited first!");
50602 const nativeResponseValue = wasm.TS_PaymentConstraints_get_max_cltv_expiry(this_ptr);
50603 return nativeResponseValue;
50605 // void PaymentConstraints_set_max_cltv_expiry(struct LDKPaymentConstraints *NONNULL_PTR this_ptr, uint32_t val);
50607 export function PaymentConstraints_set_max_cltv_expiry(this_ptr: bigint, val: number): void {
50608 if(!isWasmInitialized) {
50609 throw new Error("initializeWasm() must be awaited first!");
50611 const nativeResponseValue = wasm.TS_PaymentConstraints_set_max_cltv_expiry(this_ptr, val);
50612 // debug statements here
50614 // uint64_t PaymentConstraints_get_htlc_minimum_msat(const struct LDKPaymentConstraints *NONNULL_PTR this_ptr);
50616 export function PaymentConstraints_get_htlc_minimum_msat(this_ptr: bigint): bigint {
50617 if(!isWasmInitialized) {
50618 throw new Error("initializeWasm() must be awaited first!");
50620 const nativeResponseValue = wasm.TS_PaymentConstraints_get_htlc_minimum_msat(this_ptr);
50621 return nativeResponseValue;
50623 // void PaymentConstraints_set_htlc_minimum_msat(struct LDKPaymentConstraints *NONNULL_PTR this_ptr, uint64_t val);
50625 export function PaymentConstraints_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
50626 if(!isWasmInitialized) {
50627 throw new Error("initializeWasm() must be awaited first!");
50629 const nativeResponseValue = wasm.TS_PaymentConstraints_set_htlc_minimum_msat(this_ptr, val);
50630 // debug statements here
50632 // MUST_USE_RES struct LDKPaymentConstraints PaymentConstraints_new(uint32_t max_cltv_expiry_arg, uint64_t htlc_minimum_msat_arg);
50634 export function PaymentConstraints_new(max_cltv_expiry_arg: number, htlc_minimum_msat_arg: bigint): bigint {
50635 if(!isWasmInitialized) {
50636 throw new Error("initializeWasm() must be awaited first!");
50638 const nativeResponseValue = wasm.TS_PaymentConstraints_new(max_cltv_expiry_arg, htlc_minimum_msat_arg);
50639 return nativeResponseValue;
50641 // uint64_t PaymentConstraints_clone_ptr(LDKPaymentConstraints *NONNULL_PTR arg);
50643 export function PaymentConstraints_clone_ptr(arg: bigint): bigint {
50644 if(!isWasmInitialized) {
50645 throw new Error("initializeWasm() must be awaited first!");
50647 const nativeResponseValue = wasm.TS_PaymentConstraints_clone_ptr(arg);
50648 return nativeResponseValue;
50650 // struct LDKPaymentConstraints PaymentConstraints_clone(const struct LDKPaymentConstraints *NONNULL_PTR orig);
50652 export function PaymentConstraints_clone(orig: bigint): bigint {
50653 if(!isWasmInitialized) {
50654 throw new Error("initializeWasm() must be awaited first!");
50656 const nativeResponseValue = wasm.TS_PaymentConstraints_clone(orig);
50657 return nativeResponseValue;
50659 // struct LDKCVec_u8Z ForwardTlvs_write(const struct LDKForwardTlvs *NONNULL_PTR obj);
50661 export function ForwardTlvs_write(obj: bigint): number {
50662 if(!isWasmInitialized) {
50663 throw new Error("initializeWasm() must be awaited first!");
50665 const nativeResponseValue = wasm.TS_ForwardTlvs_write(obj);
50666 return nativeResponseValue;
50668 // struct LDKCVec_u8Z ReceiveTlvs_write(const struct LDKReceiveTlvs *NONNULL_PTR obj);
50670 export function ReceiveTlvs_write(obj: bigint): number {
50671 if(!isWasmInitialized) {
50672 throw new Error("initializeWasm() must be awaited first!");
50674 const nativeResponseValue = wasm.TS_ReceiveTlvs_write(obj);
50675 return nativeResponseValue;
50677 // struct LDKCResult_ReceiveTlvsDecodeErrorZ ReceiveTlvs_read(struct LDKu8slice ser);
50679 export function ReceiveTlvs_read(ser: number): bigint {
50680 if(!isWasmInitialized) {
50681 throw new Error("initializeWasm() must be awaited first!");
50683 const nativeResponseValue = wasm.TS_ReceiveTlvs_read(ser);
50684 return nativeResponseValue;
50686 // struct LDKCVec_u8Z PaymentRelay_write(const struct LDKPaymentRelay *NONNULL_PTR obj);
50688 export function PaymentRelay_write(obj: bigint): number {
50689 if(!isWasmInitialized) {
50690 throw new Error("initializeWasm() must be awaited first!");
50692 const nativeResponseValue = wasm.TS_PaymentRelay_write(obj);
50693 return nativeResponseValue;
50695 // struct LDKCResult_PaymentRelayDecodeErrorZ PaymentRelay_read(struct LDKu8slice ser);
50697 export function PaymentRelay_read(ser: number): bigint {
50698 if(!isWasmInitialized) {
50699 throw new Error("initializeWasm() must be awaited first!");
50701 const nativeResponseValue = wasm.TS_PaymentRelay_read(ser);
50702 return nativeResponseValue;
50704 // struct LDKCVec_u8Z PaymentConstraints_write(const struct LDKPaymentConstraints *NONNULL_PTR obj);
50706 export function PaymentConstraints_write(obj: bigint): number {
50707 if(!isWasmInitialized) {
50708 throw new Error("initializeWasm() must be awaited first!");
50710 const nativeResponseValue = wasm.TS_PaymentConstraints_write(obj);
50711 return nativeResponseValue;
50713 // struct LDKCResult_PaymentConstraintsDecodeErrorZ PaymentConstraints_read(struct LDKu8slice ser);
50715 export function PaymentConstraints_read(ser: number): bigint {
50716 if(!isWasmInitialized) {
50717 throw new Error("initializeWasm() must be awaited first!");
50719 const nativeResponseValue = wasm.TS_PaymentConstraints_read(ser);
50720 return nativeResponseValue;
50722 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
50724 export function PaymentPurpose_free(this_ptr: bigint): void {
50725 if(!isWasmInitialized) {
50726 throw new Error("initializeWasm() must be awaited first!");
50728 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
50729 // debug statements here
50731 // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
50733 export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
50734 if(!isWasmInitialized) {
50735 throw new Error("initializeWasm() must be awaited first!");
50737 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
50738 return nativeResponseValue;
50740 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
50742 export function PaymentPurpose_clone(orig: bigint): bigint {
50743 if(!isWasmInitialized) {
50744 throw new Error("initializeWasm() must be awaited first!");
50746 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
50747 return nativeResponseValue;
50749 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKThirtyTwoBytes payment_secret);
50751 export function PaymentPurpose_invoice_payment(payment_preimage: bigint, payment_secret: number): bigint {
50752 if(!isWasmInitialized) {
50753 throw new Error("initializeWasm() must be awaited first!");
50755 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
50756 return nativeResponseValue;
50758 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
50760 export function PaymentPurpose_spontaneous_payment(a: number): bigint {
50761 if(!isWasmInitialized) {
50762 throw new Error("initializeWasm() must be awaited first!");
50764 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
50765 return nativeResponseValue;
50767 // bool PaymentPurpose_eq(const struct LDKPaymentPurpose *NONNULL_PTR a, const struct LDKPaymentPurpose *NONNULL_PTR b);
50769 export function PaymentPurpose_eq(a: bigint, b: bigint): boolean {
50770 if(!isWasmInitialized) {
50771 throw new Error("initializeWasm() must be awaited first!");
50773 const nativeResponseValue = wasm.TS_PaymentPurpose_eq(a, b);
50774 return nativeResponseValue;
50776 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
50778 export function PaymentPurpose_write(obj: bigint): number {
50779 if(!isWasmInitialized) {
50780 throw new Error("initializeWasm() must be awaited first!");
50782 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
50783 return nativeResponseValue;
50785 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
50787 export function PaymentPurpose_read(ser: number): bigint {
50788 if(!isWasmInitialized) {
50789 throw new Error("initializeWasm() must be awaited first!");
50791 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
50792 return nativeResponseValue;
50794 // void ClaimedHTLC_free(struct LDKClaimedHTLC this_obj);
50796 export function ClaimedHTLC_free(this_obj: bigint): void {
50797 if(!isWasmInitialized) {
50798 throw new Error("initializeWasm() must be awaited first!");
50800 const nativeResponseValue = wasm.TS_ClaimedHTLC_free(this_obj);
50801 // debug statements here
50803 // const uint8_t (*ClaimedHTLC_get_channel_id(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr))[32];
50805 export function ClaimedHTLC_get_channel_id(this_ptr: bigint): number {
50806 if(!isWasmInitialized) {
50807 throw new Error("initializeWasm() must be awaited first!");
50809 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_channel_id(this_ptr);
50810 return nativeResponseValue;
50812 // void ClaimedHTLC_set_channel_id(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
50814 export function ClaimedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
50815 if(!isWasmInitialized) {
50816 throw new Error("initializeWasm() must be awaited first!");
50818 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_channel_id(this_ptr, val);
50819 // debug statements here
50821 // struct LDKU128 ClaimedHTLC_get_user_channel_id(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
50823 export function ClaimedHTLC_get_user_channel_id(this_ptr: bigint): number {
50824 if(!isWasmInitialized) {
50825 throw new Error("initializeWasm() must be awaited first!");
50827 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_user_channel_id(this_ptr);
50828 return nativeResponseValue;
50830 // void ClaimedHTLC_set_user_channel_id(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, struct LDKU128 val);
50832 export function ClaimedHTLC_set_user_channel_id(this_ptr: bigint, val: number): void {
50833 if(!isWasmInitialized) {
50834 throw new Error("initializeWasm() must be awaited first!");
50836 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_user_channel_id(this_ptr, val);
50837 // debug statements here
50839 // uint32_t ClaimedHTLC_get_cltv_expiry(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
50841 export function ClaimedHTLC_get_cltv_expiry(this_ptr: bigint): number {
50842 if(!isWasmInitialized) {
50843 throw new Error("initializeWasm() must be awaited first!");
50845 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_cltv_expiry(this_ptr);
50846 return nativeResponseValue;
50848 // void ClaimedHTLC_set_cltv_expiry(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, uint32_t val);
50850 export function ClaimedHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
50851 if(!isWasmInitialized) {
50852 throw new Error("initializeWasm() must be awaited first!");
50854 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_cltv_expiry(this_ptr, val);
50855 // debug statements here
50857 // uint64_t ClaimedHTLC_get_value_msat(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
50859 export function ClaimedHTLC_get_value_msat(this_ptr: bigint): bigint {
50860 if(!isWasmInitialized) {
50861 throw new Error("initializeWasm() must be awaited first!");
50863 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_value_msat(this_ptr);
50864 return nativeResponseValue;
50866 // void ClaimedHTLC_set_value_msat(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, uint64_t val);
50868 export function ClaimedHTLC_set_value_msat(this_ptr: bigint, val: bigint): void {
50869 if(!isWasmInitialized) {
50870 throw new Error("initializeWasm() must be awaited first!");
50872 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_value_msat(this_ptr, val);
50873 // debug statements here
50875 // MUST_USE_RES struct LDKClaimedHTLC ClaimedHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKU128 user_channel_id_arg, uint32_t cltv_expiry_arg, uint64_t value_msat_arg);
50877 export function ClaimedHTLC_new(channel_id_arg: number, user_channel_id_arg: number, cltv_expiry_arg: number, value_msat_arg: bigint): bigint {
50878 if(!isWasmInitialized) {
50879 throw new Error("initializeWasm() must be awaited first!");
50881 const nativeResponseValue = wasm.TS_ClaimedHTLC_new(channel_id_arg, user_channel_id_arg, cltv_expiry_arg, value_msat_arg);
50882 return nativeResponseValue;
50884 // uint64_t ClaimedHTLC_clone_ptr(LDKClaimedHTLC *NONNULL_PTR arg);
50886 export function ClaimedHTLC_clone_ptr(arg: bigint): bigint {
50887 if(!isWasmInitialized) {
50888 throw new Error("initializeWasm() must be awaited first!");
50890 const nativeResponseValue = wasm.TS_ClaimedHTLC_clone_ptr(arg);
50891 return nativeResponseValue;
50893 // struct LDKClaimedHTLC ClaimedHTLC_clone(const struct LDKClaimedHTLC *NONNULL_PTR orig);
50895 export function ClaimedHTLC_clone(orig: bigint): bigint {
50896 if(!isWasmInitialized) {
50897 throw new Error("initializeWasm() must be awaited first!");
50899 const nativeResponseValue = wasm.TS_ClaimedHTLC_clone(orig);
50900 return nativeResponseValue;
50902 // bool ClaimedHTLC_eq(const struct LDKClaimedHTLC *NONNULL_PTR a, const struct LDKClaimedHTLC *NONNULL_PTR b);
50904 export function ClaimedHTLC_eq(a: bigint, b: bigint): boolean {
50905 if(!isWasmInitialized) {
50906 throw new Error("initializeWasm() must be awaited first!");
50908 const nativeResponseValue = wasm.TS_ClaimedHTLC_eq(a, b);
50909 return nativeResponseValue;
50911 // struct LDKCVec_u8Z ClaimedHTLC_write(const struct LDKClaimedHTLC *NONNULL_PTR obj);
50913 export function ClaimedHTLC_write(obj: bigint): number {
50914 if(!isWasmInitialized) {
50915 throw new Error("initializeWasm() must be awaited first!");
50917 const nativeResponseValue = wasm.TS_ClaimedHTLC_write(obj);
50918 return nativeResponseValue;
50920 // struct LDKCResult_ClaimedHTLCDecodeErrorZ ClaimedHTLC_read(struct LDKu8slice ser);
50922 export function ClaimedHTLC_read(ser: number): bigint {
50923 if(!isWasmInitialized) {
50924 throw new Error("initializeWasm() must be awaited first!");
50926 const nativeResponseValue = wasm.TS_ClaimedHTLC_read(ser);
50927 return nativeResponseValue;
50929 // void PathFailure_free(struct LDKPathFailure this_ptr);
50931 export function PathFailure_free(this_ptr: bigint): void {
50932 if(!isWasmInitialized) {
50933 throw new Error("initializeWasm() must be awaited first!");
50935 const nativeResponseValue = wasm.TS_PathFailure_free(this_ptr);
50936 // debug statements here
50938 // uint64_t PathFailure_clone_ptr(LDKPathFailure *NONNULL_PTR arg);
50940 export function PathFailure_clone_ptr(arg: bigint): bigint {
50941 if(!isWasmInitialized) {
50942 throw new Error("initializeWasm() must be awaited first!");
50944 const nativeResponseValue = wasm.TS_PathFailure_clone_ptr(arg);
50945 return nativeResponseValue;
50947 // struct LDKPathFailure PathFailure_clone(const struct LDKPathFailure *NONNULL_PTR orig);
50949 export function PathFailure_clone(orig: bigint): bigint {
50950 if(!isWasmInitialized) {
50951 throw new Error("initializeWasm() must be awaited first!");
50953 const nativeResponseValue = wasm.TS_PathFailure_clone(orig);
50954 return nativeResponseValue;
50956 // struct LDKPathFailure PathFailure_initial_send(struct LDKAPIError err);
50958 export function PathFailure_initial_send(err: bigint): bigint {
50959 if(!isWasmInitialized) {
50960 throw new Error("initializeWasm() must be awaited first!");
50962 const nativeResponseValue = wasm.TS_PathFailure_initial_send(err);
50963 return nativeResponseValue;
50965 // struct LDKPathFailure PathFailure_on_path(struct LDKCOption_NetworkUpdateZ network_update);
50967 export function PathFailure_on_path(network_update: bigint): bigint {
50968 if(!isWasmInitialized) {
50969 throw new Error("initializeWasm() must be awaited first!");
50971 const nativeResponseValue = wasm.TS_PathFailure_on_path(network_update);
50972 return nativeResponseValue;
50974 // bool PathFailure_eq(const struct LDKPathFailure *NONNULL_PTR a, const struct LDKPathFailure *NONNULL_PTR b);
50976 export function PathFailure_eq(a: bigint, b: bigint): boolean {
50977 if(!isWasmInitialized) {
50978 throw new Error("initializeWasm() must be awaited first!");
50980 const nativeResponseValue = wasm.TS_PathFailure_eq(a, b);
50981 return nativeResponseValue;
50983 // struct LDKCVec_u8Z PathFailure_write(const struct LDKPathFailure *NONNULL_PTR obj);
50985 export function PathFailure_write(obj: bigint): number {
50986 if(!isWasmInitialized) {
50987 throw new Error("initializeWasm() must be awaited first!");
50989 const nativeResponseValue = wasm.TS_PathFailure_write(obj);
50990 return nativeResponseValue;
50992 // struct LDKCResult_COption_PathFailureZDecodeErrorZ PathFailure_read(struct LDKu8slice ser);
50994 export function PathFailure_read(ser: number): bigint {
50995 if(!isWasmInitialized) {
50996 throw new Error("initializeWasm() must be awaited first!");
50998 const nativeResponseValue = wasm.TS_PathFailure_read(ser);
50999 return nativeResponseValue;
51001 // void ClosureReason_free(struct LDKClosureReason this_ptr);
51003 export function ClosureReason_free(this_ptr: bigint): void {
51004 if(!isWasmInitialized) {
51005 throw new Error("initializeWasm() must be awaited first!");
51007 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
51008 // debug statements here
51010 // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
51012 export function ClosureReason_clone_ptr(arg: bigint): bigint {
51013 if(!isWasmInitialized) {
51014 throw new Error("initializeWasm() must be awaited first!");
51016 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
51017 return nativeResponseValue;
51019 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
51021 export function ClosureReason_clone(orig: bigint): bigint {
51022 if(!isWasmInitialized) {
51023 throw new Error("initializeWasm() must be awaited first!");
51025 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
51026 return nativeResponseValue;
51028 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKUntrustedString peer_msg);
51030 export function ClosureReason_counterparty_force_closed(peer_msg: bigint): bigint {
51031 if(!isWasmInitialized) {
51032 throw new Error("initializeWasm() must be awaited first!");
51034 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
51035 return nativeResponseValue;
51037 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
51039 export function ClosureReason_holder_force_closed(): bigint {
51040 if(!isWasmInitialized) {
51041 throw new Error("initializeWasm() must be awaited first!");
51043 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
51044 return nativeResponseValue;
51046 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
51048 export function ClosureReason_cooperative_closure(): bigint {
51049 if(!isWasmInitialized) {
51050 throw new Error("initializeWasm() must be awaited first!");
51052 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
51053 return nativeResponseValue;
51055 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
51057 export function ClosureReason_commitment_tx_confirmed(): bigint {
51058 if(!isWasmInitialized) {
51059 throw new Error("initializeWasm() must be awaited first!");
51061 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
51062 return nativeResponseValue;
51064 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
51066 export function ClosureReason_funding_timed_out(): bigint {
51067 if(!isWasmInitialized) {
51068 throw new Error("initializeWasm() must be awaited first!");
51070 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
51071 return nativeResponseValue;
51073 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
51075 export function ClosureReason_processing_error(err: number): bigint {
51076 if(!isWasmInitialized) {
51077 throw new Error("initializeWasm() must be awaited first!");
51079 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
51080 return nativeResponseValue;
51082 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
51084 export function ClosureReason_disconnected_peer(): bigint {
51085 if(!isWasmInitialized) {
51086 throw new Error("initializeWasm() must be awaited first!");
51088 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
51089 return nativeResponseValue;
51091 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
51093 export function ClosureReason_outdated_channel_manager(): bigint {
51094 if(!isWasmInitialized) {
51095 throw new Error("initializeWasm() must be awaited first!");
51097 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
51098 return nativeResponseValue;
51100 // struct LDKClosureReason ClosureReason_counterparty_coop_closed_unfunded_channel(void);
51102 export function ClosureReason_counterparty_coop_closed_unfunded_channel(): bigint {
51103 if(!isWasmInitialized) {
51104 throw new Error("initializeWasm() must be awaited first!");
51106 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_coop_closed_unfunded_channel();
51107 return nativeResponseValue;
51109 // struct LDKClosureReason ClosureReason_funding_batch_closure(void);
51111 export function ClosureReason_funding_batch_closure(): bigint {
51112 if(!isWasmInitialized) {
51113 throw new Error("initializeWasm() must be awaited first!");
51115 const nativeResponseValue = wasm.TS_ClosureReason_funding_batch_closure();
51116 return nativeResponseValue;
51118 // bool ClosureReason_eq(const struct LDKClosureReason *NONNULL_PTR a, const struct LDKClosureReason *NONNULL_PTR b);
51120 export function ClosureReason_eq(a: bigint, b: bigint): boolean {
51121 if(!isWasmInitialized) {
51122 throw new Error("initializeWasm() must be awaited first!");
51124 const nativeResponseValue = wasm.TS_ClosureReason_eq(a, b);
51125 return nativeResponseValue;
51127 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
51129 export function ClosureReason_write(obj: bigint): number {
51130 if(!isWasmInitialized) {
51131 throw new Error("initializeWasm() must be awaited first!");
51133 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
51134 return nativeResponseValue;
51136 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
51138 export function ClosureReason_read(ser: number): bigint {
51139 if(!isWasmInitialized) {
51140 throw new Error("initializeWasm() must be awaited first!");
51142 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
51143 return nativeResponseValue;
51145 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
51147 export function HTLCDestination_free(this_ptr: bigint): void {
51148 if(!isWasmInitialized) {
51149 throw new Error("initializeWasm() must be awaited first!");
51151 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
51152 // debug statements here
51154 // uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
51156 export function HTLCDestination_clone_ptr(arg: bigint): bigint {
51157 if(!isWasmInitialized) {
51158 throw new Error("initializeWasm() must be awaited first!");
51160 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
51161 return nativeResponseValue;
51163 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
51165 export function HTLCDestination_clone(orig: bigint): bigint {
51166 if(!isWasmInitialized) {
51167 throw new Error("initializeWasm() must be awaited first!");
51169 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
51170 return nativeResponseValue;
51172 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
51174 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): bigint {
51175 if(!isWasmInitialized) {
51176 throw new Error("initializeWasm() must be awaited first!");
51178 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
51179 return nativeResponseValue;
51181 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
51183 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
51184 if(!isWasmInitialized) {
51185 throw new Error("initializeWasm() must be awaited first!");
51187 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
51188 return nativeResponseValue;
51190 // struct LDKHTLCDestination HTLCDestination_invalid_forward(uint64_t requested_forward_scid);
51192 export function HTLCDestination_invalid_forward(requested_forward_scid: bigint): bigint {
51193 if(!isWasmInitialized) {
51194 throw new Error("initializeWasm() must be awaited first!");
51196 const nativeResponseValue = wasm.TS_HTLCDestination_invalid_forward(requested_forward_scid);
51197 return nativeResponseValue;
51199 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
51201 export function HTLCDestination_failed_payment(payment_hash: number): bigint {
51202 if(!isWasmInitialized) {
51203 throw new Error("initializeWasm() must be awaited first!");
51205 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
51206 return nativeResponseValue;
51208 // bool HTLCDestination_eq(const struct LDKHTLCDestination *NONNULL_PTR a, const struct LDKHTLCDestination *NONNULL_PTR b);
51210 export function HTLCDestination_eq(a: bigint, b: bigint): boolean {
51211 if(!isWasmInitialized) {
51212 throw new Error("initializeWasm() must be awaited first!");
51214 const nativeResponseValue = wasm.TS_HTLCDestination_eq(a, b);
51215 return nativeResponseValue;
51217 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
51219 export function HTLCDestination_write(obj: bigint): number {
51220 if(!isWasmInitialized) {
51221 throw new Error("initializeWasm() must be awaited first!");
51223 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
51224 return nativeResponseValue;
51226 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
51228 export function HTLCDestination_read(ser: number): bigint {
51229 if(!isWasmInitialized) {
51230 throw new Error("initializeWasm() must be awaited first!");
51232 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
51233 return nativeResponseValue;
51235 // enum LDKPaymentFailureReason PaymentFailureReason_clone(const enum LDKPaymentFailureReason *NONNULL_PTR orig);
51237 export function PaymentFailureReason_clone(orig: bigint): PaymentFailureReason {
51238 if(!isWasmInitialized) {
51239 throw new Error("initializeWasm() must be awaited first!");
51241 const nativeResponseValue = wasm.TS_PaymentFailureReason_clone(orig);
51242 return nativeResponseValue;
51244 // enum LDKPaymentFailureReason PaymentFailureReason_recipient_rejected(void);
51246 export function PaymentFailureReason_recipient_rejected(): PaymentFailureReason {
51247 if(!isWasmInitialized) {
51248 throw new Error("initializeWasm() must be awaited first!");
51250 const nativeResponseValue = wasm.TS_PaymentFailureReason_recipient_rejected();
51251 return nativeResponseValue;
51253 // enum LDKPaymentFailureReason PaymentFailureReason_user_abandoned(void);
51255 export function PaymentFailureReason_user_abandoned(): PaymentFailureReason {
51256 if(!isWasmInitialized) {
51257 throw new Error("initializeWasm() must be awaited first!");
51259 const nativeResponseValue = wasm.TS_PaymentFailureReason_user_abandoned();
51260 return nativeResponseValue;
51262 // enum LDKPaymentFailureReason PaymentFailureReason_retries_exhausted(void);
51264 export function PaymentFailureReason_retries_exhausted(): PaymentFailureReason {
51265 if(!isWasmInitialized) {
51266 throw new Error("initializeWasm() must be awaited first!");
51268 const nativeResponseValue = wasm.TS_PaymentFailureReason_retries_exhausted();
51269 return nativeResponseValue;
51271 // enum LDKPaymentFailureReason PaymentFailureReason_payment_expired(void);
51273 export function PaymentFailureReason_payment_expired(): PaymentFailureReason {
51274 if(!isWasmInitialized) {
51275 throw new Error("initializeWasm() must be awaited first!");
51277 const nativeResponseValue = wasm.TS_PaymentFailureReason_payment_expired();
51278 return nativeResponseValue;
51280 // enum LDKPaymentFailureReason PaymentFailureReason_route_not_found(void);
51282 export function PaymentFailureReason_route_not_found(): PaymentFailureReason {
51283 if(!isWasmInitialized) {
51284 throw new Error("initializeWasm() must be awaited first!");
51286 const nativeResponseValue = wasm.TS_PaymentFailureReason_route_not_found();
51287 return nativeResponseValue;
51289 // enum LDKPaymentFailureReason PaymentFailureReason_unexpected_error(void);
51291 export function PaymentFailureReason_unexpected_error(): PaymentFailureReason {
51292 if(!isWasmInitialized) {
51293 throw new Error("initializeWasm() must be awaited first!");
51295 const nativeResponseValue = wasm.TS_PaymentFailureReason_unexpected_error();
51296 return nativeResponseValue;
51298 // bool PaymentFailureReason_eq(const enum LDKPaymentFailureReason *NONNULL_PTR a, const enum LDKPaymentFailureReason *NONNULL_PTR b);
51300 export function PaymentFailureReason_eq(a: bigint, b: bigint): boolean {
51301 if(!isWasmInitialized) {
51302 throw new Error("initializeWasm() must be awaited first!");
51304 const nativeResponseValue = wasm.TS_PaymentFailureReason_eq(a, b);
51305 return nativeResponseValue;
51307 // struct LDKCVec_u8Z PaymentFailureReason_write(const enum LDKPaymentFailureReason *NONNULL_PTR obj);
51309 export function PaymentFailureReason_write(obj: bigint): number {
51310 if(!isWasmInitialized) {
51311 throw new Error("initializeWasm() must be awaited first!");
51313 const nativeResponseValue = wasm.TS_PaymentFailureReason_write(obj);
51314 return nativeResponseValue;
51316 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ PaymentFailureReason_read(struct LDKu8slice ser);
51318 export function PaymentFailureReason_read(ser: number): bigint {
51319 if(!isWasmInitialized) {
51320 throw new Error("initializeWasm() must be awaited first!");
51322 const nativeResponseValue = wasm.TS_PaymentFailureReason_read(ser);
51323 return nativeResponseValue;
51325 // void Event_free(struct LDKEvent this_ptr);
51327 export function Event_free(this_ptr: bigint): void {
51328 if(!isWasmInitialized) {
51329 throw new Error("initializeWasm() must be awaited first!");
51331 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
51332 // debug statements here
51334 // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
51336 export function Event_clone_ptr(arg: bigint): bigint {
51337 if(!isWasmInitialized) {
51338 throw new Error("initializeWasm() must be awaited first!");
51340 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
51341 return nativeResponseValue;
51343 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
51345 export function Event_clone(orig: bigint): bigint {
51346 if(!isWasmInitialized) {
51347 throw new Error("initializeWasm() must be awaited first!");
51349 const nativeResponseValue = wasm.TS_Event_clone(orig);
51350 return nativeResponseValue;
51352 // struct LDKEvent Event_funding_generation_ready(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t channel_value_satoshis, struct LDKCVec_u8Z output_script, struct LDKU128 user_channel_id);
51354 export function Event_funding_generation_ready(temporary_channel_id: number, counterparty_node_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: number): bigint {
51355 if(!isWasmInitialized) {
51356 throw new Error("initializeWasm() must be awaited first!");
51358 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
51359 return nativeResponseValue;
51361 // 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 LDKCOption_ThirtyTwoBytesZ via_channel_id, struct LDKCOption_U128Z via_user_channel_id, struct LDKCOption_u32Z claim_deadline);
51363 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 {
51364 if(!isWasmInitialized) {
51365 throw new Error("initializeWasm() must be awaited first!");
51367 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);
51368 return nativeResponseValue;
51370 // 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);
51372 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 {
51373 if(!isWasmInitialized) {
51374 throw new Error("initializeWasm() must be awaited first!");
51376 const nativeResponseValue = wasm.TS_Event_payment_claimed(receiver_node_id, payment_hash, amount_msat, purpose, htlcs, sender_intended_total_msat);
51377 return nativeResponseValue;
51379 // struct LDKEvent Event_invoice_request_failed(struct LDKThirtyTwoBytes payment_id);
51381 export function Event_invoice_request_failed(payment_id: number): bigint {
51382 if(!isWasmInitialized) {
51383 throw new Error("initializeWasm() must be awaited first!");
51385 const nativeResponseValue = wasm.TS_Event_invoice_request_failed(payment_id);
51386 return nativeResponseValue;
51388 // struct LDKEvent Event_payment_sent(struct LDKCOption_ThirtyTwoBytesZ payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
51390 export function Event_payment_sent(payment_id: bigint, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
51391 if(!isWasmInitialized) {
51392 throw new Error("initializeWasm() must be awaited first!");
51394 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
51395 return nativeResponseValue;
51397 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_PaymentFailureReasonZ reason);
51399 export function Event_payment_failed(payment_id: number, payment_hash: number, reason: bigint): bigint {
51400 if(!isWasmInitialized) {
51401 throw new Error("initializeWasm() must be awaited first!");
51403 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash, reason);
51404 return nativeResponseValue;
51406 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKCOption_ThirtyTwoBytesZ payment_hash, struct LDKPath path);
51408 export function Event_payment_path_successful(payment_id: number, payment_hash: bigint, path: bigint): bigint {
51409 if(!isWasmInitialized) {
51410 throw new Error("initializeWasm() must be awaited first!");
51412 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
51413 return nativeResponseValue;
51415 // 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);
51417 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 {
51418 if(!isWasmInitialized) {
51419 throw new Error("initializeWasm() must be awaited first!");
51421 const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, payment_failed_permanently, failure, path, short_channel_id);
51422 return nativeResponseValue;
51424 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path);
51426 export function Event_probe_successful(payment_id: number, payment_hash: number, path: bigint): bigint {
51427 if(!isWasmInitialized) {
51428 throw new Error("initializeWasm() must be awaited first!");
51430 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
51431 return nativeResponseValue;
51433 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path, struct LDKCOption_u64Z short_channel_id);
51435 export function Event_probe_failed(payment_id: number, payment_hash: number, path: bigint, short_channel_id: bigint): bigint {
51436 if(!isWasmInitialized) {
51437 throw new Error("initializeWasm() must be awaited first!");
51439 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
51440 return nativeResponseValue;
51442 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
51444 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
51445 if(!isWasmInitialized) {
51446 throw new Error("initializeWasm() must be awaited first!");
51448 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
51449 return nativeResponseValue;
51451 // 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);
51453 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 {
51454 if(!isWasmInitialized) {
51455 throw new Error("initializeWasm() must be awaited first!");
51457 const nativeResponseValue = wasm.TS_Event_htlcintercepted(intercept_id, requested_next_hop_scid, payment_hash, inbound_amount_msat, expected_outbound_amount_msat);
51458 return nativeResponseValue;
51460 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs, struct LDKCOption_ThirtyTwoBytesZ channel_id);
51462 export function Event_spendable_outputs(outputs: number, channel_id: bigint): bigint {
51463 if(!isWasmInitialized) {
51464 throw new Error("initializeWasm() must be awaited first!");
51466 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs, channel_id);
51467 return nativeResponseValue;
51469 // struct LDKEvent Event_payment_forwarded(struct LDKCOption_ThirtyTwoBytesZ prev_channel_id, struct LDKCOption_ThirtyTwoBytesZ next_channel_id, struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx, struct LDKCOption_u64Z outbound_amount_forwarded_msat);
51471 export function Event_payment_forwarded(prev_channel_id: bigint, next_channel_id: bigint, fee_earned_msat: bigint, claim_from_onchain_tx: boolean, outbound_amount_forwarded_msat: bigint): bigint {
51472 if(!isWasmInitialized) {
51473 throw new Error("initializeWasm() must be awaited first!");
51475 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx, outbound_amount_forwarded_msat);
51476 return nativeResponseValue;
51478 // struct LDKEvent Event_channel_pending(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKCOption_ThirtyTwoBytesZ former_temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKOutPoint funding_txo);
51480 export function Event_channel_pending(channel_id: number, user_channel_id: number, former_temporary_channel_id: bigint, counterparty_node_id: number, funding_txo: bigint): bigint {
51481 if(!isWasmInitialized) {
51482 throw new Error("initializeWasm() must be awaited first!");
51484 const nativeResponseValue = wasm.TS_Event_channel_pending(channel_id, user_channel_id, former_temporary_channel_id, counterparty_node_id, funding_txo);
51485 return nativeResponseValue;
51487 // struct LDKEvent Event_channel_ready(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKChannelTypeFeatures channel_type);
51489 export function Event_channel_ready(channel_id: number, user_channel_id: number, counterparty_node_id: number, channel_type: bigint): bigint {
51490 if(!isWasmInitialized) {
51491 throw new Error("initializeWasm() must be awaited first!");
51493 const nativeResponseValue = wasm.TS_Event_channel_ready(channel_id, user_channel_id, counterparty_node_id, channel_type);
51494 return nativeResponseValue;
51496 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKClosureReason reason, struct LDKPublicKey counterparty_node_id, struct LDKCOption_u64Z channel_capacity_sats);
51498 export function Event_channel_closed(channel_id: number, user_channel_id: number, reason: bigint, counterparty_node_id: number, channel_capacity_sats: bigint): bigint {
51499 if(!isWasmInitialized) {
51500 throw new Error("initializeWasm() must be awaited first!");
51502 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason, counterparty_node_id, channel_capacity_sats);
51503 return nativeResponseValue;
51505 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
51507 export function Event_discard_funding(channel_id: number, transaction: number): bigint {
51508 if(!isWasmInitialized) {
51509 throw new Error("initializeWasm() must be awaited first!");
51511 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
51512 return nativeResponseValue;
51514 // struct LDKEvent Event_open_channel_request(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t funding_satoshis, uint64_t push_msat, struct LDKChannelTypeFeatures channel_type);
51516 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
51517 if(!isWasmInitialized) {
51518 throw new Error("initializeWasm() must be awaited first!");
51520 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
51521 return nativeResponseValue;
51523 // struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
51525 export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: bigint): bigint {
51526 if(!isWasmInitialized) {
51527 throw new Error("initializeWasm() must be awaited first!");
51529 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
51530 return nativeResponseValue;
51532 // struct LDKEvent Event_bump_transaction(struct LDKBumpTransactionEvent a);
51534 export function Event_bump_transaction(a: bigint): bigint {
51535 if(!isWasmInitialized) {
51536 throw new Error("initializeWasm() must be awaited first!");
51538 const nativeResponseValue = wasm.TS_Event_bump_transaction(a);
51539 return nativeResponseValue;
51541 // bool Event_eq(const struct LDKEvent *NONNULL_PTR a, const struct LDKEvent *NONNULL_PTR b);
51543 export function Event_eq(a: bigint, b: bigint): boolean {
51544 if(!isWasmInitialized) {
51545 throw new Error("initializeWasm() must be awaited first!");
51547 const nativeResponseValue = wasm.TS_Event_eq(a, b);
51548 return nativeResponseValue;
51550 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
51552 export function Event_write(obj: bigint): number {
51553 if(!isWasmInitialized) {
51554 throw new Error("initializeWasm() must be awaited first!");
51556 const nativeResponseValue = wasm.TS_Event_write(obj);
51557 return nativeResponseValue;
51559 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
51561 export function Event_read(ser: number): bigint {
51562 if(!isWasmInitialized) {
51563 throw new Error("initializeWasm() must be awaited first!");
51565 const nativeResponseValue = wasm.TS_Event_read(ser);
51566 return nativeResponseValue;
51568 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
51570 export function MessageSendEvent_free(this_ptr: bigint): void {
51571 if(!isWasmInitialized) {
51572 throw new Error("initializeWasm() must be awaited first!");
51574 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
51575 // debug statements here
51577 // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
51579 export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
51580 if(!isWasmInitialized) {
51581 throw new Error("initializeWasm() must be awaited first!");
51583 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
51584 return nativeResponseValue;
51586 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
51588 export function MessageSendEvent_clone(orig: bigint): bigint {
51589 if(!isWasmInitialized) {
51590 throw new Error("initializeWasm() must be awaited first!");
51592 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
51593 return nativeResponseValue;
51595 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
51597 export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
51598 if(!isWasmInitialized) {
51599 throw new Error("initializeWasm() must be awaited first!");
51601 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
51602 return nativeResponseValue;
51604 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel_v2(struct LDKPublicKey node_id, struct LDKAcceptChannelV2 msg);
51606 export function MessageSendEvent_send_accept_channel_v2(node_id: number, msg: bigint): bigint {
51607 if(!isWasmInitialized) {
51608 throw new Error("initializeWasm() must be awaited first!");
51610 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel_v2(node_id, msg);
51611 return nativeResponseValue;
51613 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
51615 export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
51616 if(!isWasmInitialized) {
51617 throw new Error("initializeWasm() must be awaited first!");
51619 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
51620 return nativeResponseValue;
51622 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel_v2(struct LDKPublicKey node_id, struct LDKOpenChannelV2 msg);
51624 export function MessageSendEvent_send_open_channel_v2(node_id: number, msg: bigint): bigint {
51625 if(!isWasmInitialized) {
51626 throw new Error("initializeWasm() must be awaited first!");
51628 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel_v2(node_id, msg);
51629 return nativeResponseValue;
51631 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
51633 export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
51634 if(!isWasmInitialized) {
51635 throw new Error("initializeWasm() must be awaited first!");
51637 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
51638 return nativeResponseValue;
51640 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
51642 export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
51643 if(!isWasmInitialized) {
51644 throw new Error("initializeWasm() must be awaited first!");
51646 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
51647 return nativeResponseValue;
51649 // struct LDKMessageSendEvent MessageSendEvent_send_tx_add_input(struct LDKPublicKey node_id, struct LDKTxAddInput msg);
51651 export function MessageSendEvent_send_tx_add_input(node_id: number, msg: bigint): bigint {
51652 if(!isWasmInitialized) {
51653 throw new Error("initializeWasm() must be awaited first!");
51655 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_add_input(node_id, msg);
51656 return nativeResponseValue;
51658 // struct LDKMessageSendEvent MessageSendEvent_send_tx_add_output(struct LDKPublicKey node_id, struct LDKTxAddOutput msg);
51660 export function MessageSendEvent_send_tx_add_output(node_id: number, msg: bigint): bigint {
51661 if(!isWasmInitialized) {
51662 throw new Error("initializeWasm() must be awaited first!");
51664 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_add_output(node_id, msg);
51665 return nativeResponseValue;
51667 // struct LDKMessageSendEvent MessageSendEvent_send_tx_remove_input(struct LDKPublicKey node_id, struct LDKTxRemoveInput msg);
51669 export function MessageSendEvent_send_tx_remove_input(node_id: number, msg: bigint): bigint {
51670 if(!isWasmInitialized) {
51671 throw new Error("initializeWasm() must be awaited first!");
51673 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_remove_input(node_id, msg);
51674 return nativeResponseValue;
51676 // struct LDKMessageSendEvent MessageSendEvent_send_tx_remove_output(struct LDKPublicKey node_id, struct LDKTxRemoveOutput msg);
51678 export function MessageSendEvent_send_tx_remove_output(node_id: number, msg: bigint): bigint {
51679 if(!isWasmInitialized) {
51680 throw new Error("initializeWasm() must be awaited first!");
51682 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_remove_output(node_id, msg);
51683 return nativeResponseValue;
51685 // struct LDKMessageSendEvent MessageSendEvent_send_tx_complete(struct LDKPublicKey node_id, struct LDKTxComplete msg);
51687 export function MessageSendEvent_send_tx_complete(node_id: number, msg: bigint): bigint {
51688 if(!isWasmInitialized) {
51689 throw new Error("initializeWasm() must be awaited first!");
51691 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_complete(node_id, msg);
51692 return nativeResponseValue;
51694 // struct LDKMessageSendEvent MessageSendEvent_send_tx_signatures(struct LDKPublicKey node_id, struct LDKTxSignatures msg);
51696 export function MessageSendEvent_send_tx_signatures(node_id: number, msg: bigint): bigint {
51697 if(!isWasmInitialized) {
51698 throw new Error("initializeWasm() must be awaited first!");
51700 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_signatures(node_id, msg);
51701 return nativeResponseValue;
51703 // struct LDKMessageSendEvent MessageSendEvent_send_tx_init_rbf(struct LDKPublicKey node_id, struct LDKTxInitRbf msg);
51705 export function MessageSendEvent_send_tx_init_rbf(node_id: number, msg: bigint): bigint {
51706 if(!isWasmInitialized) {
51707 throw new Error("initializeWasm() must be awaited first!");
51709 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_init_rbf(node_id, msg);
51710 return nativeResponseValue;
51712 // struct LDKMessageSendEvent MessageSendEvent_send_tx_ack_rbf(struct LDKPublicKey node_id, struct LDKTxAckRbf msg);
51714 export function MessageSendEvent_send_tx_ack_rbf(node_id: number, msg: bigint): bigint {
51715 if(!isWasmInitialized) {
51716 throw new Error("initializeWasm() must be awaited first!");
51718 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_ack_rbf(node_id, msg);
51719 return nativeResponseValue;
51721 // struct LDKMessageSendEvent MessageSendEvent_send_tx_abort(struct LDKPublicKey node_id, struct LDKTxAbort msg);
51723 export function MessageSendEvent_send_tx_abort(node_id: number, msg: bigint): bigint {
51724 if(!isWasmInitialized) {
51725 throw new Error("initializeWasm() must be awaited first!");
51727 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_abort(node_id, msg);
51728 return nativeResponseValue;
51730 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
51732 export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
51733 if(!isWasmInitialized) {
51734 throw new Error("initializeWasm() must be awaited first!");
51736 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
51737 return nativeResponseValue;
51739 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
51741 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
51742 if(!isWasmInitialized) {
51743 throw new Error("initializeWasm() must be awaited first!");
51745 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
51746 return nativeResponseValue;
51748 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
51750 export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
51751 if(!isWasmInitialized) {
51752 throw new Error("initializeWasm() must be awaited first!");
51754 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
51755 return nativeResponseValue;
51757 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
51759 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
51760 if(!isWasmInitialized) {
51761 throw new Error("initializeWasm() must be awaited first!");
51763 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
51764 return nativeResponseValue;
51766 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
51768 export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
51769 if(!isWasmInitialized) {
51770 throw new Error("initializeWasm() must be awaited first!");
51772 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
51773 return nativeResponseValue;
51775 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
51777 export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
51778 if(!isWasmInitialized) {
51779 throw new Error("initializeWasm() must be awaited first!");
51781 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
51782 return nativeResponseValue;
51784 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
51786 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
51787 if(!isWasmInitialized) {
51788 throw new Error("initializeWasm() must be awaited first!");
51790 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
51791 return nativeResponseValue;
51793 // struct LDKMessageSendEvent MessageSendEvent_send_channel_announcement(struct LDKPublicKey node_id, struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
51795 export function MessageSendEvent_send_channel_announcement(node_id: number, msg: bigint, update_msg: bigint): bigint {
51796 if(!isWasmInitialized) {
51797 throw new Error("initializeWasm() must be awaited first!");
51799 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_announcement(node_id, msg, update_msg);
51800 return nativeResponseValue;
51802 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
51804 export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
51805 if(!isWasmInitialized) {
51806 throw new Error("initializeWasm() must be awaited first!");
51808 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
51809 return nativeResponseValue;
51811 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
51813 export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
51814 if(!isWasmInitialized) {
51815 throw new Error("initializeWasm() must be awaited first!");
51817 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
51818 return nativeResponseValue;
51820 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
51822 export function MessageSendEvent_broadcast_node_announcement(msg: bigint): bigint {
51823 if(!isWasmInitialized) {
51824 throw new Error("initializeWasm() must be awaited first!");
51826 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
51827 return nativeResponseValue;
51829 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
51831 export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
51832 if(!isWasmInitialized) {
51833 throw new Error("initializeWasm() must be awaited first!");
51835 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
51836 return nativeResponseValue;
51838 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
51840 export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
51841 if(!isWasmInitialized) {
51842 throw new Error("initializeWasm() must be awaited first!");
51844 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
51845 return nativeResponseValue;
51847 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
51849 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
51850 if(!isWasmInitialized) {
51851 throw new Error("initializeWasm() must be awaited first!");
51853 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
51854 return nativeResponseValue;
51856 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
51858 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
51859 if(!isWasmInitialized) {
51860 throw new Error("initializeWasm() must be awaited first!");
51862 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
51863 return nativeResponseValue;
51865 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
51867 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
51868 if(!isWasmInitialized) {
51869 throw new Error("initializeWasm() must be awaited first!");
51871 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
51872 return nativeResponseValue;
51874 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
51876 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
51877 if(!isWasmInitialized) {
51878 throw new Error("initializeWasm() must be awaited first!");
51880 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
51881 return nativeResponseValue;
51883 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
51885 export function MessageSendEventsProvider_free(this_ptr: bigint): void {
51886 if(!isWasmInitialized) {
51887 throw new Error("initializeWasm() must be awaited first!");
51889 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
51890 // debug statements here
51892 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
51894 export function EventsProvider_free(this_ptr: bigint): void {
51895 if(!isWasmInitialized) {
51896 throw new Error("initializeWasm() must be awaited first!");
51898 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
51899 // debug statements here
51901 // void EventHandler_free(struct LDKEventHandler this_ptr);
51903 export function EventHandler_free(this_ptr: bigint): void {
51904 if(!isWasmInitialized) {
51905 throw new Error("initializeWasm() must be awaited first!");
51907 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
51908 // debug statements here
51910 // void AnchorDescriptor_free(struct LDKAnchorDescriptor this_obj);
51912 export function AnchorDescriptor_free(this_obj: bigint): void {
51913 if(!isWasmInitialized) {
51914 throw new Error("initializeWasm() must be awaited first!");
51916 const nativeResponseValue = wasm.TS_AnchorDescriptor_free(this_obj);
51917 // debug statements here
51919 // struct LDKChannelDerivationParameters AnchorDescriptor_get_channel_derivation_parameters(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
51921 export function AnchorDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
51922 if(!isWasmInitialized) {
51923 throw new Error("initializeWasm() must be awaited first!");
51925 const nativeResponseValue = wasm.TS_AnchorDescriptor_get_channel_derivation_parameters(this_ptr);
51926 return nativeResponseValue;
51928 // void AnchorDescriptor_set_channel_derivation_parameters(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
51930 export function AnchorDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
51931 if(!isWasmInitialized) {
51932 throw new Error("initializeWasm() must be awaited first!");
51934 const nativeResponseValue = wasm.TS_AnchorDescriptor_set_channel_derivation_parameters(this_ptr, val);
51935 // debug statements here
51937 // struct LDKOutPoint AnchorDescriptor_get_outpoint(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
51939 export function AnchorDescriptor_get_outpoint(this_ptr: bigint): bigint {
51940 if(!isWasmInitialized) {
51941 throw new Error("initializeWasm() must be awaited first!");
51943 const nativeResponseValue = wasm.TS_AnchorDescriptor_get_outpoint(this_ptr);
51944 return nativeResponseValue;
51946 // void AnchorDescriptor_set_outpoint(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
51948 export function AnchorDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
51949 if(!isWasmInitialized) {
51950 throw new Error("initializeWasm() must be awaited first!");
51952 const nativeResponseValue = wasm.TS_AnchorDescriptor_set_outpoint(this_ptr, val);
51953 // debug statements here
51955 // MUST_USE_RES struct LDKAnchorDescriptor AnchorDescriptor_new(struct LDKChannelDerivationParameters channel_derivation_parameters_arg, struct LDKOutPoint outpoint_arg);
51957 export function AnchorDescriptor_new(channel_derivation_parameters_arg: bigint, outpoint_arg: bigint): bigint {
51958 if(!isWasmInitialized) {
51959 throw new Error("initializeWasm() must be awaited first!");
51961 const nativeResponseValue = wasm.TS_AnchorDescriptor_new(channel_derivation_parameters_arg, outpoint_arg);
51962 return nativeResponseValue;
51964 // uint64_t AnchorDescriptor_clone_ptr(LDKAnchorDescriptor *NONNULL_PTR arg);
51966 export function AnchorDescriptor_clone_ptr(arg: bigint): bigint {
51967 if(!isWasmInitialized) {
51968 throw new Error("initializeWasm() must be awaited first!");
51970 const nativeResponseValue = wasm.TS_AnchorDescriptor_clone_ptr(arg);
51971 return nativeResponseValue;
51973 // struct LDKAnchorDescriptor AnchorDescriptor_clone(const struct LDKAnchorDescriptor *NONNULL_PTR orig);
51975 export function AnchorDescriptor_clone(orig: bigint): bigint {
51976 if(!isWasmInitialized) {
51977 throw new Error("initializeWasm() must be awaited first!");
51979 const nativeResponseValue = wasm.TS_AnchorDescriptor_clone(orig);
51980 return nativeResponseValue;
51982 // bool AnchorDescriptor_eq(const struct LDKAnchorDescriptor *NONNULL_PTR a, const struct LDKAnchorDescriptor *NONNULL_PTR b);
51984 export function AnchorDescriptor_eq(a: bigint, b: bigint): boolean {
51985 if(!isWasmInitialized) {
51986 throw new Error("initializeWasm() must be awaited first!");
51988 const nativeResponseValue = wasm.TS_AnchorDescriptor_eq(a, b);
51989 return nativeResponseValue;
51991 // MUST_USE_RES struct LDKTxOut AnchorDescriptor_previous_utxo(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
51993 export function AnchorDescriptor_previous_utxo(this_arg: bigint): bigint {
51994 if(!isWasmInitialized) {
51995 throw new Error("initializeWasm() must be awaited first!");
51997 const nativeResponseValue = wasm.TS_AnchorDescriptor_previous_utxo(this_arg);
51998 return nativeResponseValue;
52000 // MUST_USE_RES struct LDKTxIn AnchorDescriptor_unsigned_tx_input(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
52002 export function AnchorDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
52003 if(!isWasmInitialized) {
52004 throw new Error("initializeWasm() must be awaited first!");
52006 const nativeResponseValue = wasm.TS_AnchorDescriptor_unsigned_tx_input(this_arg);
52007 return nativeResponseValue;
52009 // MUST_USE_RES struct LDKCVec_u8Z AnchorDescriptor_witness_script(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
52011 export function AnchorDescriptor_witness_script(this_arg: bigint): number {
52012 if(!isWasmInitialized) {
52013 throw new Error("initializeWasm() must be awaited first!");
52015 const nativeResponseValue = wasm.TS_AnchorDescriptor_witness_script(this_arg);
52016 return nativeResponseValue;
52018 // MUST_USE_RES struct LDKWitness AnchorDescriptor_tx_input_witness(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, struct LDKECDSASignature signature);
52020 export function AnchorDescriptor_tx_input_witness(this_arg: bigint, signature: number): number {
52021 if(!isWasmInitialized) {
52022 throw new Error("initializeWasm() must be awaited first!");
52024 const nativeResponseValue = wasm.TS_AnchorDescriptor_tx_input_witness(this_arg, signature);
52025 return nativeResponseValue;
52027 // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner AnchorDescriptor_derive_channel_signer(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
52029 export function AnchorDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
52030 if(!isWasmInitialized) {
52031 throw new Error("initializeWasm() must be awaited first!");
52033 const nativeResponseValue = wasm.TS_AnchorDescriptor_derive_channel_signer(this_arg, signer_provider);
52034 return nativeResponseValue;
52036 // void BumpTransactionEvent_free(struct LDKBumpTransactionEvent this_ptr);
52038 export function BumpTransactionEvent_free(this_ptr: bigint): void {
52039 if(!isWasmInitialized) {
52040 throw new Error("initializeWasm() must be awaited first!");
52042 const nativeResponseValue = wasm.TS_BumpTransactionEvent_free(this_ptr);
52043 // debug statements here
52045 // uint64_t BumpTransactionEvent_clone_ptr(LDKBumpTransactionEvent *NONNULL_PTR arg);
52047 export function BumpTransactionEvent_clone_ptr(arg: bigint): bigint {
52048 if(!isWasmInitialized) {
52049 throw new Error("initializeWasm() must be awaited first!");
52051 const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone_ptr(arg);
52052 return nativeResponseValue;
52054 // struct LDKBumpTransactionEvent BumpTransactionEvent_clone(const struct LDKBumpTransactionEvent *NONNULL_PTR orig);
52056 export function BumpTransactionEvent_clone(orig: bigint): bigint {
52057 if(!isWasmInitialized) {
52058 throw new Error("initializeWasm() must be awaited first!");
52060 const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone(orig);
52061 return nativeResponseValue;
52063 // struct LDKBumpTransactionEvent BumpTransactionEvent_channel_close(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);
52065 export function BumpTransactionEvent_channel_close(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 {
52066 if(!isWasmInitialized) {
52067 throw new Error("initializeWasm() must be awaited first!");
52069 const nativeResponseValue = wasm.TS_BumpTransactionEvent_channel_close(claim_id, package_target_feerate_sat_per_1000_weight, commitment_tx, commitment_tx_fee_satoshis, anchor_descriptor, pending_htlcs);
52070 return nativeResponseValue;
52072 // struct LDKBumpTransactionEvent BumpTransactionEvent_htlcresolution(struct LDKThirtyTwoBytes claim_id, uint32_t target_feerate_sat_per_1000_weight, struct LDKCVec_HTLCDescriptorZ htlc_descriptors, uint32_t tx_lock_time);
52074 export function BumpTransactionEvent_htlcresolution(claim_id: number, target_feerate_sat_per_1000_weight: number, htlc_descriptors: number, tx_lock_time: number): bigint {
52075 if(!isWasmInitialized) {
52076 throw new Error("initializeWasm() must be awaited first!");
52078 const nativeResponseValue = wasm.TS_BumpTransactionEvent_htlcresolution(claim_id, target_feerate_sat_per_1000_weight, htlc_descriptors, tx_lock_time);
52079 return nativeResponseValue;
52081 // bool BumpTransactionEvent_eq(const struct LDKBumpTransactionEvent *NONNULL_PTR a, const struct LDKBumpTransactionEvent *NONNULL_PTR b);
52083 export function BumpTransactionEvent_eq(a: bigint, b: bigint): boolean {
52084 if(!isWasmInitialized) {
52085 throw new Error("initializeWasm() must be awaited first!");
52087 const nativeResponseValue = wasm.TS_BumpTransactionEvent_eq(a, b);
52088 return nativeResponseValue;
52090 // void Input_free(struct LDKInput this_obj);
52092 export function Input_free(this_obj: bigint): void {
52093 if(!isWasmInitialized) {
52094 throw new Error("initializeWasm() must be awaited first!");
52096 const nativeResponseValue = wasm.TS_Input_free(this_obj);
52097 // debug statements here
52099 // struct LDKOutPoint Input_get_outpoint(const struct LDKInput *NONNULL_PTR this_ptr);
52101 export function Input_get_outpoint(this_ptr: bigint): bigint {
52102 if(!isWasmInitialized) {
52103 throw new Error("initializeWasm() must be awaited first!");
52105 const nativeResponseValue = wasm.TS_Input_get_outpoint(this_ptr);
52106 return nativeResponseValue;
52108 // void Input_set_outpoint(struct LDKInput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
52110 export function Input_set_outpoint(this_ptr: bigint, val: bigint): void {
52111 if(!isWasmInitialized) {
52112 throw new Error("initializeWasm() must be awaited first!");
52114 const nativeResponseValue = wasm.TS_Input_set_outpoint(this_ptr, val);
52115 // debug statements here
52117 // struct LDKTxOut Input_get_previous_utxo(const struct LDKInput *NONNULL_PTR this_ptr);
52119 export function Input_get_previous_utxo(this_ptr: bigint): bigint {
52120 if(!isWasmInitialized) {
52121 throw new Error("initializeWasm() must be awaited first!");
52123 const nativeResponseValue = wasm.TS_Input_get_previous_utxo(this_ptr);
52124 return nativeResponseValue;
52126 // void Input_set_previous_utxo(struct LDKInput *NONNULL_PTR this_ptr, struct LDKTxOut val);
52128 export function Input_set_previous_utxo(this_ptr: bigint, val: bigint): void {
52129 if(!isWasmInitialized) {
52130 throw new Error("initializeWasm() must be awaited first!");
52132 const nativeResponseValue = wasm.TS_Input_set_previous_utxo(this_ptr, val);
52133 // debug statements here
52135 // uint64_t Input_get_satisfaction_weight(const struct LDKInput *NONNULL_PTR this_ptr);
52137 export function Input_get_satisfaction_weight(this_ptr: bigint): bigint {
52138 if(!isWasmInitialized) {
52139 throw new Error("initializeWasm() must be awaited first!");
52141 const nativeResponseValue = wasm.TS_Input_get_satisfaction_weight(this_ptr);
52142 return nativeResponseValue;
52144 // void Input_set_satisfaction_weight(struct LDKInput *NONNULL_PTR this_ptr, uint64_t val);
52146 export function Input_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
52147 if(!isWasmInitialized) {
52148 throw new Error("initializeWasm() must be awaited first!");
52150 const nativeResponseValue = wasm.TS_Input_set_satisfaction_weight(this_ptr, val);
52151 // debug statements here
52153 // MUST_USE_RES struct LDKInput Input_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut previous_utxo_arg, uint64_t satisfaction_weight_arg);
52155 export function Input_new(outpoint_arg: bigint, previous_utxo_arg: bigint, satisfaction_weight_arg: bigint): bigint {
52156 if(!isWasmInitialized) {
52157 throw new Error("initializeWasm() must be awaited first!");
52159 const nativeResponseValue = wasm.TS_Input_new(outpoint_arg, previous_utxo_arg, satisfaction_weight_arg);
52160 return nativeResponseValue;
52162 // uint64_t Input_clone_ptr(LDKInput *NONNULL_PTR arg);
52164 export function Input_clone_ptr(arg: bigint): bigint {
52165 if(!isWasmInitialized) {
52166 throw new Error("initializeWasm() must be awaited first!");
52168 const nativeResponseValue = wasm.TS_Input_clone_ptr(arg);
52169 return nativeResponseValue;
52171 // struct LDKInput Input_clone(const struct LDKInput *NONNULL_PTR orig);
52173 export function Input_clone(orig: bigint): bigint {
52174 if(!isWasmInitialized) {
52175 throw new Error("initializeWasm() must be awaited first!");
52177 const nativeResponseValue = wasm.TS_Input_clone(orig);
52178 return nativeResponseValue;
52180 // uint64_t Input_hash(const struct LDKInput *NONNULL_PTR o);
52182 export function Input_hash(o: bigint): bigint {
52183 if(!isWasmInitialized) {
52184 throw new Error("initializeWasm() must be awaited first!");
52186 const nativeResponseValue = wasm.TS_Input_hash(o);
52187 return nativeResponseValue;
52189 // bool Input_eq(const struct LDKInput *NONNULL_PTR a, const struct LDKInput *NONNULL_PTR b);
52191 export function Input_eq(a: bigint, b: bigint): boolean {
52192 if(!isWasmInitialized) {
52193 throw new Error("initializeWasm() must be awaited first!");
52195 const nativeResponseValue = wasm.TS_Input_eq(a, b);
52196 return nativeResponseValue;
52198 // void Utxo_free(struct LDKUtxo this_obj);
52200 export function Utxo_free(this_obj: bigint): void {
52201 if(!isWasmInitialized) {
52202 throw new Error("initializeWasm() must be awaited first!");
52204 const nativeResponseValue = wasm.TS_Utxo_free(this_obj);
52205 // debug statements here
52207 // struct LDKOutPoint Utxo_get_outpoint(const struct LDKUtxo *NONNULL_PTR this_ptr);
52209 export function Utxo_get_outpoint(this_ptr: bigint): bigint {
52210 if(!isWasmInitialized) {
52211 throw new Error("initializeWasm() must be awaited first!");
52213 const nativeResponseValue = wasm.TS_Utxo_get_outpoint(this_ptr);
52214 return nativeResponseValue;
52216 // void Utxo_set_outpoint(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKOutPoint val);
52218 export function Utxo_set_outpoint(this_ptr: bigint, val: bigint): void {
52219 if(!isWasmInitialized) {
52220 throw new Error("initializeWasm() must be awaited first!");
52222 const nativeResponseValue = wasm.TS_Utxo_set_outpoint(this_ptr, val);
52223 // debug statements here
52225 // struct LDKTxOut Utxo_get_output(const struct LDKUtxo *NONNULL_PTR this_ptr);
52227 export function Utxo_get_output(this_ptr: bigint): bigint {
52228 if(!isWasmInitialized) {
52229 throw new Error("initializeWasm() must be awaited first!");
52231 const nativeResponseValue = wasm.TS_Utxo_get_output(this_ptr);
52232 return nativeResponseValue;
52234 // void Utxo_set_output(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKTxOut val);
52236 export function Utxo_set_output(this_ptr: bigint, val: bigint): void {
52237 if(!isWasmInitialized) {
52238 throw new Error("initializeWasm() must be awaited first!");
52240 const nativeResponseValue = wasm.TS_Utxo_set_output(this_ptr, val);
52241 // debug statements here
52243 // uint64_t Utxo_get_satisfaction_weight(const struct LDKUtxo *NONNULL_PTR this_ptr);
52245 export function Utxo_get_satisfaction_weight(this_ptr: bigint): bigint {
52246 if(!isWasmInitialized) {
52247 throw new Error("initializeWasm() must be awaited first!");
52249 const nativeResponseValue = wasm.TS_Utxo_get_satisfaction_weight(this_ptr);
52250 return nativeResponseValue;
52252 // void Utxo_set_satisfaction_weight(struct LDKUtxo *NONNULL_PTR this_ptr, uint64_t val);
52254 export function Utxo_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
52255 if(!isWasmInitialized) {
52256 throw new Error("initializeWasm() must be awaited first!");
52258 const nativeResponseValue = wasm.TS_Utxo_set_satisfaction_weight(this_ptr, val);
52259 // debug statements here
52261 // MUST_USE_RES struct LDKUtxo Utxo_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut output_arg, uint64_t satisfaction_weight_arg);
52263 export function Utxo_new(outpoint_arg: bigint, output_arg: bigint, satisfaction_weight_arg: bigint): bigint {
52264 if(!isWasmInitialized) {
52265 throw new Error("initializeWasm() must be awaited first!");
52267 const nativeResponseValue = wasm.TS_Utxo_new(outpoint_arg, output_arg, satisfaction_weight_arg);
52268 return nativeResponseValue;
52270 // uint64_t Utxo_clone_ptr(LDKUtxo *NONNULL_PTR arg);
52272 export function Utxo_clone_ptr(arg: bigint): bigint {
52273 if(!isWasmInitialized) {
52274 throw new Error("initializeWasm() must be awaited first!");
52276 const nativeResponseValue = wasm.TS_Utxo_clone_ptr(arg);
52277 return nativeResponseValue;
52279 // struct LDKUtxo Utxo_clone(const struct LDKUtxo *NONNULL_PTR orig);
52281 export function Utxo_clone(orig: bigint): bigint {
52282 if(!isWasmInitialized) {
52283 throw new Error("initializeWasm() must be awaited first!");
52285 const nativeResponseValue = wasm.TS_Utxo_clone(orig);
52286 return nativeResponseValue;
52288 // uint64_t Utxo_hash(const struct LDKUtxo *NONNULL_PTR o);
52290 export function Utxo_hash(o: bigint): bigint {
52291 if(!isWasmInitialized) {
52292 throw new Error("initializeWasm() must be awaited first!");
52294 const nativeResponseValue = wasm.TS_Utxo_hash(o);
52295 return nativeResponseValue;
52297 // bool Utxo_eq(const struct LDKUtxo *NONNULL_PTR a, const struct LDKUtxo *NONNULL_PTR b);
52299 export function Utxo_eq(a: bigint, b: bigint): boolean {
52300 if(!isWasmInitialized) {
52301 throw new Error("initializeWasm() must be awaited first!");
52303 const nativeResponseValue = wasm.TS_Utxo_eq(a, b);
52304 return nativeResponseValue;
52306 // MUST_USE_RES struct LDKUtxo Utxo_new_p2pkh(struct LDKOutPoint outpoint, uint64_t value, const uint8_t (*pubkey_hash)[20]);
52308 export function Utxo_new_p2pkh(outpoint: bigint, value: bigint, pubkey_hash: number): bigint {
52309 if(!isWasmInitialized) {
52310 throw new Error("initializeWasm() must be awaited first!");
52312 const nativeResponseValue = wasm.TS_Utxo_new_p2pkh(outpoint, value, pubkey_hash);
52313 return nativeResponseValue;
52315 // void CoinSelection_free(struct LDKCoinSelection this_obj);
52317 export function CoinSelection_free(this_obj: bigint): void {
52318 if(!isWasmInitialized) {
52319 throw new Error("initializeWasm() must be awaited first!");
52321 const nativeResponseValue = wasm.TS_CoinSelection_free(this_obj);
52322 // debug statements here
52324 // struct LDKCVec_UtxoZ CoinSelection_get_confirmed_utxos(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
52326 export function CoinSelection_get_confirmed_utxos(this_ptr: bigint): number {
52327 if(!isWasmInitialized) {
52328 throw new Error("initializeWasm() must be awaited first!");
52330 const nativeResponseValue = wasm.TS_CoinSelection_get_confirmed_utxos(this_ptr);
52331 return nativeResponseValue;
52333 // void CoinSelection_set_confirmed_utxos(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCVec_UtxoZ val);
52335 export function CoinSelection_set_confirmed_utxos(this_ptr: bigint, val: number): void {
52336 if(!isWasmInitialized) {
52337 throw new Error("initializeWasm() must be awaited first!");
52339 const nativeResponseValue = wasm.TS_CoinSelection_set_confirmed_utxos(this_ptr, val);
52340 // debug statements here
52342 // struct LDKCOption_TxOutZ CoinSelection_get_change_output(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
52344 export function CoinSelection_get_change_output(this_ptr: bigint): bigint {
52345 if(!isWasmInitialized) {
52346 throw new Error("initializeWasm() must be awaited first!");
52348 const nativeResponseValue = wasm.TS_CoinSelection_get_change_output(this_ptr);
52349 return nativeResponseValue;
52351 // void CoinSelection_set_change_output(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCOption_TxOutZ val);
52353 export function CoinSelection_set_change_output(this_ptr: bigint, val: bigint): void {
52354 if(!isWasmInitialized) {
52355 throw new Error("initializeWasm() must be awaited first!");
52357 const nativeResponseValue = wasm.TS_CoinSelection_set_change_output(this_ptr, val);
52358 // debug statements here
52360 // MUST_USE_RES struct LDKCoinSelection CoinSelection_new(struct LDKCVec_UtxoZ confirmed_utxos_arg, struct LDKCOption_TxOutZ change_output_arg);
52362 export function CoinSelection_new(confirmed_utxos_arg: number, change_output_arg: bigint): bigint {
52363 if(!isWasmInitialized) {
52364 throw new Error("initializeWasm() must be awaited first!");
52366 const nativeResponseValue = wasm.TS_CoinSelection_new(confirmed_utxos_arg, change_output_arg);
52367 return nativeResponseValue;
52369 // uint64_t CoinSelection_clone_ptr(LDKCoinSelection *NONNULL_PTR arg);
52371 export function CoinSelection_clone_ptr(arg: bigint): bigint {
52372 if(!isWasmInitialized) {
52373 throw new Error("initializeWasm() must be awaited first!");
52375 const nativeResponseValue = wasm.TS_CoinSelection_clone_ptr(arg);
52376 return nativeResponseValue;
52378 // struct LDKCoinSelection CoinSelection_clone(const struct LDKCoinSelection *NONNULL_PTR orig);
52380 export function CoinSelection_clone(orig: bigint): bigint {
52381 if(!isWasmInitialized) {
52382 throw new Error("initializeWasm() must be awaited first!");
52384 const nativeResponseValue = wasm.TS_CoinSelection_clone(orig);
52385 return nativeResponseValue;
52387 // void CoinSelectionSource_free(struct LDKCoinSelectionSource this_ptr);
52389 export function CoinSelectionSource_free(this_ptr: bigint): void {
52390 if(!isWasmInitialized) {
52391 throw new Error("initializeWasm() must be awaited first!");
52393 const nativeResponseValue = wasm.TS_CoinSelectionSource_free(this_ptr);
52394 // debug statements here
52396 // void WalletSource_free(struct LDKWalletSource this_ptr);
52398 export function WalletSource_free(this_ptr: bigint): void {
52399 if(!isWasmInitialized) {
52400 throw new Error("initializeWasm() must be awaited first!");
52402 const nativeResponseValue = wasm.TS_WalletSource_free(this_ptr);
52403 // debug statements here
52405 // void Wallet_free(struct LDKWallet this_obj);
52407 export function Wallet_free(this_obj: bigint): void {
52408 if(!isWasmInitialized) {
52409 throw new Error("initializeWasm() must be awaited first!");
52411 const nativeResponseValue = wasm.TS_Wallet_free(this_obj);
52412 // debug statements here
52414 // MUST_USE_RES struct LDKWallet Wallet_new(struct LDKWalletSource source, struct LDKLogger logger);
52416 export function Wallet_new(source: bigint, logger: bigint): bigint {
52417 if(!isWasmInitialized) {
52418 throw new Error("initializeWasm() must be awaited first!");
52420 const nativeResponseValue = wasm.TS_Wallet_new(source, logger);
52421 return nativeResponseValue;
52423 // struct LDKCoinSelectionSource Wallet_as_CoinSelectionSource(const struct LDKWallet *NONNULL_PTR this_arg);
52425 export function Wallet_as_CoinSelectionSource(this_arg: bigint): bigint {
52426 if(!isWasmInitialized) {
52427 throw new Error("initializeWasm() must be awaited first!");
52429 const nativeResponseValue = wasm.TS_Wallet_as_CoinSelectionSource(this_arg);
52430 return nativeResponseValue;
52432 // void BumpTransactionEventHandler_free(struct LDKBumpTransactionEventHandler this_obj);
52434 export function BumpTransactionEventHandler_free(this_obj: bigint): void {
52435 if(!isWasmInitialized) {
52436 throw new Error("initializeWasm() must be awaited first!");
52438 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_free(this_obj);
52439 // debug statements here
52441 // MUST_USE_RES struct LDKBumpTransactionEventHandler BumpTransactionEventHandler_new(struct LDKBroadcasterInterface broadcaster, struct LDKCoinSelectionSource utxo_source, struct LDKSignerProvider signer_provider, struct LDKLogger logger);
52443 export function BumpTransactionEventHandler_new(broadcaster: bigint, utxo_source: bigint, signer_provider: bigint, logger: bigint): bigint {
52444 if(!isWasmInitialized) {
52445 throw new Error("initializeWasm() must be awaited first!");
52447 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_new(broadcaster, utxo_source, signer_provider, logger);
52448 return nativeResponseValue;
52450 // void BumpTransactionEventHandler_handle_event(const struct LDKBumpTransactionEventHandler *NONNULL_PTR this_arg, const struct LDKBumpTransactionEvent *NONNULL_PTR event);
52452 export function BumpTransactionEventHandler_handle_event(this_arg: bigint, event: bigint): void {
52453 if(!isWasmInitialized) {
52454 throw new Error("initializeWasm() must be awaited first!");
52456 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_handle_event(this_arg, event);
52457 // debug statements here
52459 // void GossipSync_free(struct LDKGossipSync this_ptr);
52461 export function GossipSync_free(this_ptr: bigint): void {
52462 if(!isWasmInitialized) {
52463 throw new Error("initializeWasm() must be awaited first!");
52465 const nativeResponseValue = wasm.TS_GossipSync_free(this_ptr);
52466 // debug statements here
52468 // struct LDKGossipSync GossipSync_p2_p(const struct LDKP2PGossipSync *NONNULL_PTR a);
52470 export function GossipSync_p2_p(a: bigint): bigint {
52471 if(!isWasmInitialized) {
52472 throw new Error("initializeWasm() must be awaited first!");
52474 const nativeResponseValue = wasm.TS_GossipSync_p2_p(a);
52475 return nativeResponseValue;
52477 // struct LDKGossipSync GossipSync_rapid(const struct LDKRapidGossipSync *NONNULL_PTR a);
52479 export function GossipSync_rapid(a: bigint): bigint {
52480 if(!isWasmInitialized) {
52481 throw new Error("initializeWasm() must be awaited first!");
52483 const nativeResponseValue = wasm.TS_GossipSync_rapid(a);
52484 return nativeResponseValue;
52486 // struct LDKGossipSync GossipSync_none(void);
52488 export function GossipSync_none(): bigint {
52489 if(!isWasmInitialized) {
52490 throw new Error("initializeWasm() must be awaited first!");
52492 const nativeResponseValue = wasm.TS_GossipSync_none();
52493 return nativeResponseValue;
52495 // void RapidGossipSync_free(struct LDKRapidGossipSync this_obj);
52497 export function RapidGossipSync_free(this_obj: bigint): void {
52498 if(!isWasmInitialized) {
52499 throw new Error("initializeWasm() must be awaited first!");
52501 const nativeResponseValue = wasm.TS_RapidGossipSync_free(this_obj);
52502 // debug statements here
52504 // MUST_USE_RES struct LDKRapidGossipSync RapidGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
52506 export function RapidGossipSync_new(network_graph: bigint, logger: bigint): bigint {
52507 if(!isWasmInitialized) {
52508 throw new Error("initializeWasm() must be awaited first!");
52510 const nativeResponseValue = wasm.TS_RapidGossipSync_new(network_graph, logger);
52511 return nativeResponseValue;
52513 // 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);
52515 export function RapidGossipSync_update_network_graph_no_std(this_arg: bigint, update_data: number, current_time_unix: bigint): bigint {
52516 if(!isWasmInitialized) {
52517 throw new Error("initializeWasm() must be awaited first!");
52519 const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph_no_std(this_arg, update_data, current_time_unix);
52520 return nativeResponseValue;
52522 // MUST_USE_RES bool RapidGossipSync_is_initial_sync_complete(const struct LDKRapidGossipSync *NONNULL_PTR this_arg);
52524 export function RapidGossipSync_is_initial_sync_complete(this_arg: bigint): boolean {
52525 if(!isWasmInitialized) {
52526 throw new Error("initializeWasm() must be awaited first!");
52528 const nativeResponseValue = wasm.TS_RapidGossipSync_is_initial_sync_complete(this_arg);
52529 return nativeResponseValue;
52531 // void GraphSyncError_free(struct LDKGraphSyncError this_ptr);
52533 export function GraphSyncError_free(this_ptr: bigint): void {
52534 if(!isWasmInitialized) {
52535 throw new Error("initializeWasm() must be awaited first!");
52537 const nativeResponseValue = wasm.TS_GraphSyncError_free(this_ptr);
52538 // debug statements here
52540 // uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg);
52542 export function GraphSyncError_clone_ptr(arg: bigint): bigint {
52543 if(!isWasmInitialized) {
52544 throw new Error("initializeWasm() must be awaited first!");
52546 const nativeResponseValue = wasm.TS_GraphSyncError_clone_ptr(arg);
52547 return nativeResponseValue;
52549 // struct LDKGraphSyncError GraphSyncError_clone(const struct LDKGraphSyncError *NONNULL_PTR orig);
52551 export function GraphSyncError_clone(orig: bigint): bigint {
52552 if(!isWasmInitialized) {
52553 throw new Error("initializeWasm() must be awaited first!");
52555 const nativeResponseValue = wasm.TS_GraphSyncError_clone(orig);
52556 return nativeResponseValue;
52558 // struct LDKGraphSyncError GraphSyncError_decode_error(struct LDKDecodeError a);
52560 export function GraphSyncError_decode_error(a: bigint): bigint {
52561 if(!isWasmInitialized) {
52562 throw new Error("initializeWasm() must be awaited first!");
52564 const nativeResponseValue = wasm.TS_GraphSyncError_decode_error(a);
52565 return nativeResponseValue;
52567 // struct LDKGraphSyncError GraphSyncError_lightning_error(struct LDKLightningError a);
52569 export function GraphSyncError_lightning_error(a: bigint): bigint {
52570 if(!isWasmInitialized) {
52571 throw new Error("initializeWasm() must be awaited first!");
52573 const nativeResponseValue = wasm.TS_GraphSyncError_lightning_error(a);
52574 return nativeResponseValue;
52576 // void Bolt11ParseError_free(struct LDKBolt11ParseError this_ptr);
52578 export function Bolt11ParseError_free(this_ptr: bigint): void {
52579 if(!isWasmInitialized) {
52580 throw new Error("initializeWasm() must be awaited first!");
52582 const nativeResponseValue = wasm.TS_Bolt11ParseError_free(this_ptr);
52583 // debug statements here
52585 // uint64_t Bolt11ParseError_clone_ptr(LDKBolt11ParseError *NONNULL_PTR arg);
52587 export function Bolt11ParseError_clone_ptr(arg: bigint): bigint {
52588 if(!isWasmInitialized) {
52589 throw new Error("initializeWasm() must be awaited first!");
52591 const nativeResponseValue = wasm.TS_Bolt11ParseError_clone_ptr(arg);
52592 return nativeResponseValue;
52594 // struct LDKBolt11ParseError Bolt11ParseError_clone(const struct LDKBolt11ParseError *NONNULL_PTR orig);
52596 export function Bolt11ParseError_clone(orig: bigint): bigint {
52597 if(!isWasmInitialized) {
52598 throw new Error("initializeWasm() must be awaited first!");
52600 const nativeResponseValue = wasm.TS_Bolt11ParseError_clone(orig);
52601 return nativeResponseValue;
52603 // struct LDKBolt11ParseError Bolt11ParseError_bech32_error(struct LDKBech32Error a);
52605 export function Bolt11ParseError_bech32_error(a: bigint): bigint {
52606 if(!isWasmInitialized) {
52607 throw new Error("initializeWasm() must be awaited first!");
52609 const nativeResponseValue = wasm.TS_Bolt11ParseError_bech32_error(a);
52610 return nativeResponseValue;
52612 // struct LDKBolt11ParseError Bolt11ParseError_parse_amount_error(struct LDKError a);
52614 export function Bolt11ParseError_parse_amount_error(a: number): bigint {
52615 if(!isWasmInitialized) {
52616 throw new Error("initializeWasm() must be awaited first!");
52618 const nativeResponseValue = wasm.TS_Bolt11ParseError_parse_amount_error(a);
52619 return nativeResponseValue;
52621 // struct LDKBolt11ParseError Bolt11ParseError_malformed_signature(enum LDKSecp256k1Error a);
52623 export function Bolt11ParseError_malformed_signature(a: Secp256k1Error): bigint {
52624 if(!isWasmInitialized) {
52625 throw new Error("initializeWasm() must be awaited first!");
52627 const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_signature(a);
52628 return nativeResponseValue;
52630 // struct LDKBolt11ParseError Bolt11ParseError_bad_prefix(void);
52632 export function Bolt11ParseError_bad_prefix(): bigint {
52633 if(!isWasmInitialized) {
52634 throw new Error("initializeWasm() must be awaited first!");
52636 const nativeResponseValue = wasm.TS_Bolt11ParseError_bad_prefix();
52637 return nativeResponseValue;
52639 // struct LDKBolt11ParseError Bolt11ParseError_unknown_currency(void);
52641 export function Bolt11ParseError_unknown_currency(): bigint {
52642 if(!isWasmInitialized) {
52643 throw new Error("initializeWasm() must be awaited first!");
52645 const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_currency();
52646 return nativeResponseValue;
52648 // struct LDKBolt11ParseError Bolt11ParseError_unknown_si_prefix(void);
52650 export function Bolt11ParseError_unknown_si_prefix(): bigint {
52651 if(!isWasmInitialized) {
52652 throw new Error("initializeWasm() must be awaited first!");
52654 const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_si_prefix();
52655 return nativeResponseValue;
52657 // struct LDKBolt11ParseError Bolt11ParseError_malformed_hrp(void);
52659 export function Bolt11ParseError_malformed_hrp(): bigint {
52660 if(!isWasmInitialized) {
52661 throw new Error("initializeWasm() must be awaited first!");
52663 const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_hrp();
52664 return nativeResponseValue;
52666 // struct LDKBolt11ParseError Bolt11ParseError_too_short_data_part(void);
52668 export function Bolt11ParseError_too_short_data_part(): bigint {
52669 if(!isWasmInitialized) {
52670 throw new Error("initializeWasm() must be awaited first!");
52672 const nativeResponseValue = wasm.TS_Bolt11ParseError_too_short_data_part();
52673 return nativeResponseValue;
52675 // struct LDKBolt11ParseError Bolt11ParseError_unexpected_end_of_tagged_fields(void);
52677 export function Bolt11ParseError_unexpected_end_of_tagged_fields(): bigint {
52678 if(!isWasmInitialized) {
52679 throw new Error("initializeWasm() must be awaited first!");
52681 const nativeResponseValue = wasm.TS_Bolt11ParseError_unexpected_end_of_tagged_fields();
52682 return nativeResponseValue;
52684 // struct LDKBolt11ParseError Bolt11ParseError_description_decode_error(struct LDKError a);
52686 export function Bolt11ParseError_description_decode_error(a: number): bigint {
52687 if(!isWasmInitialized) {
52688 throw new Error("initializeWasm() must be awaited first!");
52690 const nativeResponseValue = wasm.TS_Bolt11ParseError_description_decode_error(a);
52691 return nativeResponseValue;
52693 // struct LDKBolt11ParseError Bolt11ParseError_padding_error(void);
52695 export function Bolt11ParseError_padding_error(): bigint {
52696 if(!isWasmInitialized) {
52697 throw new Error("initializeWasm() must be awaited first!");
52699 const nativeResponseValue = wasm.TS_Bolt11ParseError_padding_error();
52700 return nativeResponseValue;
52702 // struct LDKBolt11ParseError Bolt11ParseError_integer_overflow_error(void);
52704 export function Bolt11ParseError_integer_overflow_error(): bigint {
52705 if(!isWasmInitialized) {
52706 throw new Error("initializeWasm() must be awaited first!");
52708 const nativeResponseValue = wasm.TS_Bolt11ParseError_integer_overflow_error();
52709 return nativeResponseValue;
52711 // struct LDKBolt11ParseError Bolt11ParseError_invalid_seg_wit_program_length(void);
52713 export function Bolt11ParseError_invalid_seg_wit_program_length(): bigint {
52714 if(!isWasmInitialized) {
52715 throw new Error("initializeWasm() must be awaited first!");
52717 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_seg_wit_program_length();
52718 return nativeResponseValue;
52720 // struct LDKBolt11ParseError Bolt11ParseError_invalid_pub_key_hash_length(void);
52722 export function Bolt11ParseError_invalid_pub_key_hash_length(): bigint {
52723 if(!isWasmInitialized) {
52724 throw new Error("initializeWasm() must be awaited first!");
52726 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_pub_key_hash_length();
52727 return nativeResponseValue;
52729 // struct LDKBolt11ParseError Bolt11ParseError_invalid_script_hash_length(void);
52731 export function Bolt11ParseError_invalid_script_hash_length(): bigint {
52732 if(!isWasmInitialized) {
52733 throw new Error("initializeWasm() must be awaited first!");
52735 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_script_hash_length();
52736 return nativeResponseValue;
52738 // struct LDKBolt11ParseError Bolt11ParseError_invalid_recovery_id(void);
52740 export function Bolt11ParseError_invalid_recovery_id(): bigint {
52741 if(!isWasmInitialized) {
52742 throw new Error("initializeWasm() must be awaited first!");
52744 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_recovery_id();
52745 return nativeResponseValue;
52747 // struct LDKBolt11ParseError Bolt11ParseError_invalid_slice_length(struct LDKStr a);
52749 export function Bolt11ParseError_invalid_slice_length(a: number): bigint {
52750 if(!isWasmInitialized) {
52751 throw new Error("initializeWasm() must be awaited first!");
52753 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_slice_length(a);
52754 return nativeResponseValue;
52756 // struct LDKBolt11ParseError Bolt11ParseError_skip(void);
52758 export function Bolt11ParseError_skip(): bigint {
52759 if(!isWasmInitialized) {
52760 throw new Error("initializeWasm() must be awaited first!");
52762 const nativeResponseValue = wasm.TS_Bolt11ParseError_skip();
52763 return nativeResponseValue;
52765 // bool Bolt11ParseError_eq(const struct LDKBolt11ParseError *NONNULL_PTR a, const struct LDKBolt11ParseError *NONNULL_PTR b);
52767 export function Bolt11ParseError_eq(a: bigint, b: bigint): boolean {
52768 if(!isWasmInitialized) {
52769 throw new Error("initializeWasm() must be awaited first!");
52771 const nativeResponseValue = wasm.TS_Bolt11ParseError_eq(a, b);
52772 return nativeResponseValue;
52774 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
52776 export function ParseOrSemanticError_free(this_ptr: bigint): void {
52777 if(!isWasmInitialized) {
52778 throw new Error("initializeWasm() must be awaited first!");
52780 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
52781 // debug statements here
52783 // uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
52785 export function ParseOrSemanticError_clone_ptr(arg: bigint): bigint {
52786 if(!isWasmInitialized) {
52787 throw new Error("initializeWasm() must be awaited first!");
52789 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
52790 return nativeResponseValue;
52792 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
52794 export function ParseOrSemanticError_clone(orig: bigint): bigint {
52795 if(!isWasmInitialized) {
52796 throw new Error("initializeWasm() must be awaited first!");
52798 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
52799 return nativeResponseValue;
52801 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKBolt11ParseError a);
52803 export function ParseOrSemanticError_parse_error(a: bigint): bigint {
52804 if(!isWasmInitialized) {
52805 throw new Error("initializeWasm() must be awaited first!");
52807 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
52808 return nativeResponseValue;
52810 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKBolt11SemanticError a);
52812 export function ParseOrSemanticError_semantic_error(a: Bolt11SemanticError): bigint {
52813 if(!isWasmInitialized) {
52814 throw new Error("initializeWasm() must be awaited first!");
52816 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
52817 return nativeResponseValue;
52819 // bool ParseOrSemanticError_eq(const struct LDKParseOrSemanticError *NONNULL_PTR a, const struct LDKParseOrSemanticError *NONNULL_PTR b);
52821 export function ParseOrSemanticError_eq(a: bigint, b: bigint): boolean {
52822 if(!isWasmInitialized) {
52823 throw new Error("initializeWasm() must be awaited first!");
52825 const nativeResponseValue = wasm.TS_ParseOrSemanticError_eq(a, b);
52826 return nativeResponseValue;
52828 // void Bolt11Invoice_free(struct LDKBolt11Invoice this_obj);
52830 export function Bolt11Invoice_free(this_obj: bigint): void {
52831 if(!isWasmInitialized) {
52832 throw new Error("initializeWasm() must be awaited first!");
52834 const nativeResponseValue = wasm.TS_Bolt11Invoice_free(this_obj);
52835 // debug statements here
52837 // bool Bolt11Invoice_eq(const struct LDKBolt11Invoice *NONNULL_PTR a, const struct LDKBolt11Invoice *NONNULL_PTR b);
52839 export function Bolt11Invoice_eq(a: bigint, b: bigint): boolean {
52840 if(!isWasmInitialized) {
52841 throw new Error("initializeWasm() must be awaited first!");
52843 const nativeResponseValue = wasm.TS_Bolt11Invoice_eq(a, b);
52844 return nativeResponseValue;
52846 // uint64_t Bolt11Invoice_clone_ptr(LDKBolt11Invoice *NONNULL_PTR arg);
52848 export function Bolt11Invoice_clone_ptr(arg: bigint): bigint {
52849 if(!isWasmInitialized) {
52850 throw new Error("initializeWasm() must be awaited first!");
52852 const nativeResponseValue = wasm.TS_Bolt11Invoice_clone_ptr(arg);
52853 return nativeResponseValue;
52855 // struct LDKBolt11Invoice Bolt11Invoice_clone(const struct LDKBolt11Invoice *NONNULL_PTR orig);
52857 export function Bolt11Invoice_clone(orig: bigint): bigint {
52858 if(!isWasmInitialized) {
52859 throw new Error("initializeWasm() must be awaited first!");
52861 const nativeResponseValue = wasm.TS_Bolt11Invoice_clone(orig);
52862 return nativeResponseValue;
52864 // uint64_t Bolt11Invoice_hash(const struct LDKBolt11Invoice *NONNULL_PTR o);
52866 export function Bolt11Invoice_hash(o: bigint): bigint {
52867 if(!isWasmInitialized) {
52868 throw new Error("initializeWasm() must be awaited first!");
52870 const nativeResponseValue = wasm.TS_Bolt11Invoice_hash(o);
52871 return nativeResponseValue;
52873 // void SignedRawBolt11Invoice_free(struct LDKSignedRawBolt11Invoice this_obj);
52875 export function SignedRawBolt11Invoice_free(this_obj: bigint): void {
52876 if(!isWasmInitialized) {
52877 throw new Error("initializeWasm() must be awaited first!");
52879 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_free(this_obj);
52880 // debug statements here
52882 // bool SignedRawBolt11Invoice_eq(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR a, const struct LDKSignedRawBolt11Invoice *NONNULL_PTR b);
52884 export function SignedRawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
52885 if(!isWasmInitialized) {
52886 throw new Error("initializeWasm() must be awaited first!");
52888 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_eq(a, b);
52889 return nativeResponseValue;
52891 // uint64_t SignedRawBolt11Invoice_clone_ptr(LDKSignedRawBolt11Invoice *NONNULL_PTR arg);
52893 export function SignedRawBolt11Invoice_clone_ptr(arg: bigint): bigint {
52894 if(!isWasmInitialized) {
52895 throw new Error("initializeWasm() must be awaited first!");
52897 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone_ptr(arg);
52898 return nativeResponseValue;
52900 // struct LDKSignedRawBolt11Invoice SignedRawBolt11Invoice_clone(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR orig);
52902 export function SignedRawBolt11Invoice_clone(orig: bigint): bigint {
52903 if(!isWasmInitialized) {
52904 throw new Error("initializeWasm() must be awaited first!");
52906 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone(orig);
52907 return nativeResponseValue;
52909 // uint64_t SignedRawBolt11Invoice_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
52911 export function SignedRawBolt11Invoice_hash(o: bigint): bigint {
52912 if(!isWasmInitialized) {
52913 throw new Error("initializeWasm() must be awaited first!");
52915 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_hash(o);
52916 return nativeResponseValue;
52918 // void RawBolt11Invoice_free(struct LDKRawBolt11Invoice this_obj);
52920 export function RawBolt11Invoice_free(this_obj: bigint): void {
52921 if(!isWasmInitialized) {
52922 throw new Error("initializeWasm() must be awaited first!");
52924 const nativeResponseValue = wasm.TS_RawBolt11Invoice_free(this_obj);
52925 // debug statements here
52927 // struct LDKRawDataPart RawBolt11Invoice_get_data(const struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr);
52929 export function RawBolt11Invoice_get_data(this_ptr: bigint): bigint {
52930 if(!isWasmInitialized) {
52931 throw new Error("initializeWasm() must be awaited first!");
52933 const nativeResponseValue = wasm.TS_RawBolt11Invoice_get_data(this_ptr);
52934 return nativeResponseValue;
52936 // void RawBolt11Invoice_set_data(struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
52938 export function RawBolt11Invoice_set_data(this_ptr: bigint, val: bigint): void {
52939 if(!isWasmInitialized) {
52940 throw new Error("initializeWasm() must be awaited first!");
52942 const nativeResponseValue = wasm.TS_RawBolt11Invoice_set_data(this_ptr, val);
52943 // debug statements here
52945 // bool RawBolt11Invoice_eq(const struct LDKRawBolt11Invoice *NONNULL_PTR a, const struct LDKRawBolt11Invoice *NONNULL_PTR b);
52947 export function RawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
52948 if(!isWasmInitialized) {
52949 throw new Error("initializeWasm() must be awaited first!");
52951 const nativeResponseValue = wasm.TS_RawBolt11Invoice_eq(a, b);
52952 return nativeResponseValue;
52954 // uint64_t RawBolt11Invoice_clone_ptr(LDKRawBolt11Invoice *NONNULL_PTR arg);
52956 export function RawBolt11Invoice_clone_ptr(arg: bigint): bigint {
52957 if(!isWasmInitialized) {
52958 throw new Error("initializeWasm() must be awaited first!");
52960 const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone_ptr(arg);
52961 return nativeResponseValue;
52963 // struct LDKRawBolt11Invoice RawBolt11Invoice_clone(const struct LDKRawBolt11Invoice *NONNULL_PTR orig);
52965 export function RawBolt11Invoice_clone(orig: bigint): bigint {
52966 if(!isWasmInitialized) {
52967 throw new Error("initializeWasm() must be awaited first!");
52969 const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone(orig);
52970 return nativeResponseValue;
52972 // uint64_t RawBolt11Invoice_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR o);
52974 export function RawBolt11Invoice_hash(o: bigint): bigint {
52975 if(!isWasmInitialized) {
52976 throw new Error("initializeWasm() must be awaited first!");
52978 const nativeResponseValue = wasm.TS_RawBolt11Invoice_hash(o);
52979 return nativeResponseValue;
52981 // void RawDataPart_free(struct LDKRawDataPart this_obj);
52983 export function RawDataPart_free(this_obj: bigint): void {
52984 if(!isWasmInitialized) {
52985 throw new Error("initializeWasm() must be awaited first!");
52987 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
52988 // debug statements here
52990 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
52992 export function RawDataPart_get_timestamp(this_ptr: bigint): bigint {
52993 if(!isWasmInitialized) {
52994 throw new Error("initializeWasm() must be awaited first!");
52996 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
52997 return nativeResponseValue;
52999 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
53001 export function RawDataPart_set_timestamp(this_ptr: bigint, val: bigint): void {
53002 if(!isWasmInitialized) {
53003 throw new Error("initializeWasm() must be awaited first!");
53005 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
53006 // debug statements here
53008 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
53010 export function RawDataPart_eq(a: bigint, b: bigint): boolean {
53011 if(!isWasmInitialized) {
53012 throw new Error("initializeWasm() must be awaited first!");
53014 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
53015 return nativeResponseValue;
53017 // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
53019 export function RawDataPart_clone_ptr(arg: bigint): bigint {
53020 if(!isWasmInitialized) {
53021 throw new Error("initializeWasm() must be awaited first!");
53023 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
53024 return nativeResponseValue;
53026 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
53028 export function RawDataPart_clone(orig: bigint): bigint {
53029 if(!isWasmInitialized) {
53030 throw new Error("initializeWasm() must be awaited first!");
53032 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
53033 return nativeResponseValue;
53035 // uint64_t RawDataPart_hash(const struct LDKRawDataPart *NONNULL_PTR o);
53037 export function RawDataPart_hash(o: bigint): bigint {
53038 if(!isWasmInitialized) {
53039 throw new Error("initializeWasm() must be awaited first!");
53041 const nativeResponseValue = wasm.TS_RawDataPart_hash(o);
53042 return nativeResponseValue;
53044 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
53046 export function PositiveTimestamp_free(this_obj: bigint): void {
53047 if(!isWasmInitialized) {
53048 throw new Error("initializeWasm() must be awaited first!");
53050 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
53051 // debug statements here
53053 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
53055 export function PositiveTimestamp_eq(a: bigint, b: bigint): boolean {
53056 if(!isWasmInitialized) {
53057 throw new Error("initializeWasm() must be awaited first!");
53059 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
53060 return nativeResponseValue;
53062 // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
53064 export function PositiveTimestamp_clone_ptr(arg: bigint): bigint {
53065 if(!isWasmInitialized) {
53066 throw new Error("initializeWasm() must be awaited first!");
53068 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
53069 return nativeResponseValue;
53071 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
53073 export function PositiveTimestamp_clone(orig: bigint): bigint {
53074 if(!isWasmInitialized) {
53075 throw new Error("initializeWasm() must be awaited first!");
53077 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
53078 return nativeResponseValue;
53080 // uint64_t PositiveTimestamp_hash(const struct LDKPositiveTimestamp *NONNULL_PTR o);
53082 export function PositiveTimestamp_hash(o: bigint): bigint {
53083 if(!isWasmInitialized) {
53084 throw new Error("initializeWasm() must be awaited first!");
53086 const nativeResponseValue = wasm.TS_PositiveTimestamp_hash(o);
53087 return nativeResponseValue;
53089 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
53091 export function SiPrefix_clone(orig: bigint): SiPrefix {
53092 if(!isWasmInitialized) {
53093 throw new Error("initializeWasm() must be awaited first!");
53095 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
53096 return nativeResponseValue;
53098 // enum LDKSiPrefix SiPrefix_milli(void);
53100 export function SiPrefix_milli(): SiPrefix {
53101 if(!isWasmInitialized) {
53102 throw new Error("initializeWasm() must be awaited first!");
53104 const nativeResponseValue = wasm.TS_SiPrefix_milli();
53105 return nativeResponseValue;
53107 // enum LDKSiPrefix SiPrefix_micro(void);
53109 export function SiPrefix_micro(): SiPrefix {
53110 if(!isWasmInitialized) {
53111 throw new Error("initializeWasm() must be awaited first!");
53113 const nativeResponseValue = wasm.TS_SiPrefix_micro();
53114 return nativeResponseValue;
53116 // enum LDKSiPrefix SiPrefix_nano(void);
53118 export function SiPrefix_nano(): SiPrefix {
53119 if(!isWasmInitialized) {
53120 throw new Error("initializeWasm() must be awaited first!");
53122 const nativeResponseValue = wasm.TS_SiPrefix_nano();
53123 return nativeResponseValue;
53125 // enum LDKSiPrefix SiPrefix_pico(void);
53127 export function SiPrefix_pico(): SiPrefix {
53128 if(!isWasmInitialized) {
53129 throw new Error("initializeWasm() must be awaited first!");
53131 const nativeResponseValue = wasm.TS_SiPrefix_pico();
53132 return nativeResponseValue;
53134 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
53136 export function SiPrefix_eq(a: bigint, b: bigint): boolean {
53137 if(!isWasmInitialized) {
53138 throw new Error("initializeWasm() must be awaited first!");
53140 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
53141 return nativeResponseValue;
53143 // uint64_t SiPrefix_hash(const enum LDKSiPrefix *NONNULL_PTR o);
53145 export function SiPrefix_hash(o: bigint): bigint {
53146 if(!isWasmInitialized) {
53147 throw new Error("initializeWasm() must be awaited first!");
53149 const nativeResponseValue = wasm.TS_SiPrefix_hash(o);
53150 return nativeResponseValue;
53152 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
53154 export function SiPrefix_multiplier(this_arg: bigint): bigint {
53155 if(!isWasmInitialized) {
53156 throw new Error("initializeWasm() must be awaited first!");
53158 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
53159 return nativeResponseValue;
53161 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
53163 export function Currency_clone(orig: bigint): Currency {
53164 if(!isWasmInitialized) {
53165 throw new Error("initializeWasm() must be awaited first!");
53167 const nativeResponseValue = wasm.TS_Currency_clone(orig);
53168 return nativeResponseValue;
53170 // enum LDKCurrency Currency_bitcoin(void);
53172 export function Currency_bitcoin(): Currency {
53173 if(!isWasmInitialized) {
53174 throw new Error("initializeWasm() must be awaited first!");
53176 const nativeResponseValue = wasm.TS_Currency_bitcoin();
53177 return nativeResponseValue;
53179 // enum LDKCurrency Currency_bitcoin_testnet(void);
53181 export function Currency_bitcoin_testnet(): Currency {
53182 if(!isWasmInitialized) {
53183 throw new Error("initializeWasm() must be awaited first!");
53185 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
53186 return nativeResponseValue;
53188 // enum LDKCurrency Currency_regtest(void);
53190 export function Currency_regtest(): Currency {
53191 if(!isWasmInitialized) {
53192 throw new Error("initializeWasm() must be awaited first!");
53194 const nativeResponseValue = wasm.TS_Currency_regtest();
53195 return nativeResponseValue;
53197 // enum LDKCurrency Currency_simnet(void);
53199 export function Currency_simnet(): Currency {
53200 if(!isWasmInitialized) {
53201 throw new Error("initializeWasm() must be awaited first!");
53203 const nativeResponseValue = wasm.TS_Currency_simnet();
53204 return nativeResponseValue;
53206 // enum LDKCurrency Currency_signet(void);
53208 export function Currency_signet(): Currency {
53209 if(!isWasmInitialized) {
53210 throw new Error("initializeWasm() must be awaited first!");
53212 const nativeResponseValue = wasm.TS_Currency_signet();
53213 return nativeResponseValue;
53215 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
53217 export function Currency_hash(o: bigint): bigint {
53218 if(!isWasmInitialized) {
53219 throw new Error("initializeWasm() must be awaited first!");
53221 const nativeResponseValue = wasm.TS_Currency_hash(o);
53222 return nativeResponseValue;
53224 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
53226 export function Currency_eq(a: bigint, b: bigint): boolean {
53227 if(!isWasmInitialized) {
53228 throw new Error("initializeWasm() must be awaited first!");
53230 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
53231 return nativeResponseValue;
53233 // void Sha256_free(struct LDKSha256 this_obj);
53235 export function Sha256_free(this_obj: bigint): void {
53236 if(!isWasmInitialized) {
53237 throw new Error("initializeWasm() must be awaited first!");
53239 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
53240 // debug statements here
53242 // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
53244 export function Sha256_clone_ptr(arg: bigint): bigint {
53245 if(!isWasmInitialized) {
53246 throw new Error("initializeWasm() must be awaited first!");
53248 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
53249 return nativeResponseValue;
53251 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
53253 export function Sha256_clone(orig: bigint): bigint {
53254 if(!isWasmInitialized) {
53255 throw new Error("initializeWasm() must be awaited first!");
53257 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
53258 return nativeResponseValue;
53260 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
53262 export function Sha256_hash(o: bigint): bigint {
53263 if(!isWasmInitialized) {
53264 throw new Error("initializeWasm() must be awaited first!");
53266 const nativeResponseValue = wasm.TS_Sha256_hash(o);
53267 return nativeResponseValue;
53269 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
53271 export function Sha256_eq(a: bigint, b: bigint): boolean {
53272 if(!isWasmInitialized) {
53273 throw new Error("initializeWasm() must be awaited first!");
53275 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
53276 return nativeResponseValue;
53278 // MUST_USE_RES struct LDKSha256 Sha256_from_bytes(const uint8_t (*bytes)[32]);
53280 export function Sha256_from_bytes(bytes: number): bigint {
53281 if(!isWasmInitialized) {
53282 throw new Error("initializeWasm() must be awaited first!");
53284 const nativeResponseValue = wasm.TS_Sha256_from_bytes(bytes);
53285 return nativeResponseValue;
53287 // void Description_free(struct LDKDescription this_obj);
53289 export function Description_free(this_obj: bigint): void {
53290 if(!isWasmInitialized) {
53291 throw new Error("initializeWasm() must be awaited first!");
53293 const nativeResponseValue = wasm.TS_Description_free(this_obj);
53294 // debug statements here
53296 // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
53298 export function Description_clone_ptr(arg: bigint): bigint {
53299 if(!isWasmInitialized) {
53300 throw new Error("initializeWasm() must be awaited first!");
53302 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
53303 return nativeResponseValue;
53305 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
53307 export function Description_clone(orig: bigint): bigint {
53308 if(!isWasmInitialized) {
53309 throw new Error("initializeWasm() must be awaited first!");
53311 const nativeResponseValue = wasm.TS_Description_clone(orig);
53312 return nativeResponseValue;
53314 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
53316 export function Description_hash(o: bigint): bigint {
53317 if(!isWasmInitialized) {
53318 throw new Error("initializeWasm() must be awaited first!");
53320 const nativeResponseValue = wasm.TS_Description_hash(o);
53321 return nativeResponseValue;
53323 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
53325 export function Description_eq(a: bigint, b: bigint): boolean {
53326 if(!isWasmInitialized) {
53327 throw new Error("initializeWasm() must be awaited first!");
53329 const nativeResponseValue = wasm.TS_Description_eq(a, b);
53330 return nativeResponseValue;
53332 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
53334 export function PayeePubKey_free(this_obj: bigint): void {
53335 if(!isWasmInitialized) {
53336 throw new Error("initializeWasm() must be awaited first!");
53338 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
53339 // debug statements here
53341 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
53343 export function PayeePubKey_get_a(this_ptr: bigint): number {
53344 if(!isWasmInitialized) {
53345 throw new Error("initializeWasm() must be awaited first!");
53347 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
53348 return nativeResponseValue;
53350 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
53352 export function PayeePubKey_set_a(this_ptr: bigint, val: number): void {
53353 if(!isWasmInitialized) {
53354 throw new Error("initializeWasm() must be awaited first!");
53356 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
53357 // debug statements here
53359 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
53361 export function PayeePubKey_new(a_arg: number): bigint {
53362 if(!isWasmInitialized) {
53363 throw new Error("initializeWasm() must be awaited first!");
53365 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
53366 return nativeResponseValue;
53368 // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
53370 export function PayeePubKey_clone_ptr(arg: bigint): bigint {
53371 if(!isWasmInitialized) {
53372 throw new Error("initializeWasm() must be awaited first!");
53374 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
53375 return nativeResponseValue;
53377 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
53379 export function PayeePubKey_clone(orig: bigint): bigint {
53380 if(!isWasmInitialized) {
53381 throw new Error("initializeWasm() must be awaited first!");
53383 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
53384 return nativeResponseValue;
53386 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
53388 export function PayeePubKey_hash(o: bigint): bigint {
53389 if(!isWasmInitialized) {
53390 throw new Error("initializeWasm() must be awaited first!");
53392 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
53393 return nativeResponseValue;
53395 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
53397 export function PayeePubKey_eq(a: bigint, b: bigint): boolean {
53398 if(!isWasmInitialized) {
53399 throw new Error("initializeWasm() must be awaited first!");
53401 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
53402 return nativeResponseValue;
53404 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
53406 export function ExpiryTime_free(this_obj: bigint): void {
53407 if(!isWasmInitialized) {
53408 throw new Error("initializeWasm() must be awaited first!");
53410 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
53411 // debug statements here
53413 // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
53415 export function ExpiryTime_clone_ptr(arg: bigint): bigint {
53416 if(!isWasmInitialized) {
53417 throw new Error("initializeWasm() must be awaited first!");
53419 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
53420 return nativeResponseValue;
53422 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
53424 export function ExpiryTime_clone(orig: bigint): bigint {
53425 if(!isWasmInitialized) {
53426 throw new Error("initializeWasm() must be awaited first!");
53428 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
53429 return nativeResponseValue;
53431 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
53433 export function ExpiryTime_hash(o: bigint): bigint {
53434 if(!isWasmInitialized) {
53435 throw new Error("initializeWasm() must be awaited first!");
53437 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
53438 return nativeResponseValue;
53440 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
53442 export function ExpiryTime_eq(a: bigint, b: bigint): boolean {
53443 if(!isWasmInitialized) {
53444 throw new Error("initializeWasm() must be awaited first!");
53446 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
53447 return nativeResponseValue;
53449 // void MinFinalCltvExpiryDelta_free(struct LDKMinFinalCltvExpiryDelta this_obj);
53451 export function MinFinalCltvExpiryDelta_free(this_obj: bigint): void {
53452 if(!isWasmInitialized) {
53453 throw new Error("initializeWasm() must be awaited first!");
53455 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_free(this_obj);
53456 // debug statements here
53458 // uint64_t MinFinalCltvExpiryDelta_get_a(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr);
53460 export function MinFinalCltvExpiryDelta_get_a(this_ptr: bigint): bigint {
53461 if(!isWasmInitialized) {
53462 throw new Error("initializeWasm() must be awaited first!");
53464 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_get_a(this_ptr);
53465 return nativeResponseValue;
53467 // void MinFinalCltvExpiryDelta_set_a(struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr, uint64_t val);
53469 export function MinFinalCltvExpiryDelta_set_a(this_ptr: bigint, val: bigint): void {
53470 if(!isWasmInitialized) {
53471 throw new Error("initializeWasm() must be awaited first!");
53473 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_set_a(this_ptr, val);
53474 // debug statements here
53476 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_new(uint64_t a_arg);
53478 export function MinFinalCltvExpiryDelta_new(a_arg: bigint): bigint {
53479 if(!isWasmInitialized) {
53480 throw new Error("initializeWasm() must be awaited first!");
53482 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_new(a_arg);
53483 return nativeResponseValue;
53485 // uint64_t MinFinalCltvExpiryDelta_clone_ptr(LDKMinFinalCltvExpiryDelta *NONNULL_PTR arg);
53487 export function MinFinalCltvExpiryDelta_clone_ptr(arg: bigint): bigint {
53488 if(!isWasmInitialized) {
53489 throw new Error("initializeWasm() must be awaited first!");
53491 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone_ptr(arg);
53492 return nativeResponseValue;
53494 // struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_clone(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR orig);
53496 export function MinFinalCltvExpiryDelta_clone(orig: bigint): bigint {
53497 if(!isWasmInitialized) {
53498 throw new Error("initializeWasm() must be awaited first!");
53500 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone(orig);
53501 return nativeResponseValue;
53503 // uint64_t MinFinalCltvExpiryDelta_hash(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR o);
53505 export function MinFinalCltvExpiryDelta_hash(o: bigint): bigint {
53506 if(!isWasmInitialized) {
53507 throw new Error("initializeWasm() must be awaited first!");
53509 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_hash(o);
53510 return nativeResponseValue;
53512 // bool MinFinalCltvExpiryDelta_eq(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR a, const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR b);
53514 export function MinFinalCltvExpiryDelta_eq(a: bigint, b: bigint): boolean {
53515 if(!isWasmInitialized) {
53516 throw new Error("initializeWasm() must be awaited first!");
53518 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_eq(a, b);
53519 return nativeResponseValue;
53521 // void Fallback_free(struct LDKFallback this_ptr);
53523 export function Fallback_free(this_ptr: bigint): void {
53524 if(!isWasmInitialized) {
53525 throw new Error("initializeWasm() must be awaited first!");
53527 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
53528 // debug statements here
53530 // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
53532 export function Fallback_clone_ptr(arg: bigint): bigint {
53533 if(!isWasmInitialized) {
53534 throw new Error("initializeWasm() must be awaited first!");
53536 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
53537 return nativeResponseValue;
53539 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
53541 export function Fallback_clone(orig: bigint): bigint {
53542 if(!isWasmInitialized) {
53543 throw new Error("initializeWasm() must be awaited first!");
53545 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
53546 return nativeResponseValue;
53548 // struct LDKFallback Fallback_seg_wit_program(struct LDKWitnessVersion version, struct LDKCVec_u8Z program);
53550 export function Fallback_seg_wit_program(version: number, program: number): bigint {
53551 if(!isWasmInitialized) {
53552 throw new Error("initializeWasm() must be awaited first!");
53554 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
53555 return nativeResponseValue;
53557 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
53559 export function Fallback_pub_key_hash(a: number): bigint {
53560 if(!isWasmInitialized) {
53561 throw new Error("initializeWasm() must be awaited first!");
53563 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
53564 return nativeResponseValue;
53566 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
53568 export function Fallback_script_hash(a: number): bigint {
53569 if(!isWasmInitialized) {
53570 throw new Error("initializeWasm() must be awaited first!");
53572 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
53573 return nativeResponseValue;
53575 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
53577 export function Fallback_hash(o: bigint): bigint {
53578 if(!isWasmInitialized) {
53579 throw new Error("initializeWasm() must be awaited first!");
53581 const nativeResponseValue = wasm.TS_Fallback_hash(o);
53582 return nativeResponseValue;
53584 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
53586 export function Fallback_eq(a: bigint, b: bigint): boolean {
53587 if(!isWasmInitialized) {
53588 throw new Error("initializeWasm() must be awaited first!");
53590 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
53591 return nativeResponseValue;
53593 // void Bolt11InvoiceSignature_free(struct LDKBolt11InvoiceSignature this_obj);
53595 export function Bolt11InvoiceSignature_free(this_obj: bigint): void {
53596 if(!isWasmInitialized) {
53597 throw new Error("initializeWasm() must be awaited first!");
53599 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_free(this_obj);
53600 // debug statements here
53602 // uint64_t Bolt11InvoiceSignature_clone_ptr(LDKBolt11InvoiceSignature *NONNULL_PTR arg);
53604 export function Bolt11InvoiceSignature_clone_ptr(arg: bigint): bigint {
53605 if(!isWasmInitialized) {
53606 throw new Error("initializeWasm() must be awaited first!");
53608 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone_ptr(arg);
53609 return nativeResponseValue;
53611 // struct LDKBolt11InvoiceSignature Bolt11InvoiceSignature_clone(const struct LDKBolt11InvoiceSignature *NONNULL_PTR orig);
53613 export function Bolt11InvoiceSignature_clone(orig: bigint): bigint {
53614 if(!isWasmInitialized) {
53615 throw new Error("initializeWasm() must be awaited first!");
53617 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone(orig);
53618 return nativeResponseValue;
53620 // uint64_t Bolt11InvoiceSignature_hash(const struct LDKBolt11InvoiceSignature *NONNULL_PTR o);
53622 export function Bolt11InvoiceSignature_hash(o: bigint): bigint {
53623 if(!isWasmInitialized) {
53624 throw new Error("initializeWasm() must be awaited first!");
53626 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_hash(o);
53627 return nativeResponseValue;
53629 // bool Bolt11InvoiceSignature_eq(const struct LDKBolt11InvoiceSignature *NONNULL_PTR a, const struct LDKBolt11InvoiceSignature *NONNULL_PTR b);
53631 export function Bolt11InvoiceSignature_eq(a: bigint, b: bigint): boolean {
53632 if(!isWasmInitialized) {
53633 throw new Error("initializeWasm() must be awaited first!");
53635 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_eq(a, b);
53636 return nativeResponseValue;
53638 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
53640 export function PrivateRoute_free(this_obj: bigint): void {
53641 if(!isWasmInitialized) {
53642 throw new Error("initializeWasm() must be awaited first!");
53644 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
53645 // debug statements here
53647 // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
53649 export function PrivateRoute_clone_ptr(arg: bigint): bigint {
53650 if(!isWasmInitialized) {
53651 throw new Error("initializeWasm() must be awaited first!");
53653 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
53654 return nativeResponseValue;
53656 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
53658 export function PrivateRoute_clone(orig: bigint): bigint {
53659 if(!isWasmInitialized) {
53660 throw new Error("initializeWasm() must be awaited first!");
53662 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
53663 return nativeResponseValue;
53665 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
53667 export function PrivateRoute_hash(o: bigint): bigint {
53668 if(!isWasmInitialized) {
53669 throw new Error("initializeWasm() must be awaited first!");
53671 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
53672 return nativeResponseValue;
53674 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
53676 export function PrivateRoute_eq(a: bigint, b: bigint): boolean {
53677 if(!isWasmInitialized) {
53678 throw new Error("initializeWasm() must be awaited first!");
53680 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
53681 return nativeResponseValue;
53683 // MUST_USE_RES struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ SignedRawBolt11Invoice_into_parts(struct LDKSignedRawBolt11Invoice this_arg);
53685 export function SignedRawBolt11Invoice_into_parts(this_arg: bigint): bigint {
53686 if(!isWasmInitialized) {
53687 throw new Error("initializeWasm() must be awaited first!");
53689 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_into_parts(this_arg);
53690 return nativeResponseValue;
53692 // MUST_USE_RES struct LDKRawBolt11Invoice SignedRawBolt11Invoice_raw_invoice(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
53694 export function SignedRawBolt11Invoice_raw_invoice(this_arg: bigint): bigint {
53695 if(!isWasmInitialized) {
53696 throw new Error("initializeWasm() must be awaited first!");
53698 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_raw_invoice(this_arg);
53699 return nativeResponseValue;
53701 // MUST_USE_RES const uint8_t (*SignedRawBolt11Invoice_signable_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg))[32];
53703 export function SignedRawBolt11Invoice_signable_hash(this_arg: bigint): number {
53704 if(!isWasmInitialized) {
53705 throw new Error("initializeWasm() must be awaited first!");
53707 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signable_hash(this_arg);
53708 return nativeResponseValue;
53710 // MUST_USE_RES struct LDKBolt11InvoiceSignature SignedRawBolt11Invoice_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
53712 export function SignedRawBolt11Invoice_signature(this_arg: bigint): bigint {
53713 if(!isWasmInitialized) {
53714 throw new Error("initializeWasm() must be awaited first!");
53716 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signature(this_arg);
53717 return nativeResponseValue;
53719 // MUST_USE_RES struct LDKCResult_PayeePubKeySecp256k1ErrorZ SignedRawBolt11Invoice_recover_payee_pub_key(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
53721 export function SignedRawBolt11Invoice_recover_payee_pub_key(this_arg: bigint): bigint {
53722 if(!isWasmInitialized) {
53723 throw new Error("initializeWasm() must be awaited first!");
53725 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_recover_payee_pub_key(this_arg);
53726 return nativeResponseValue;
53728 // MUST_USE_RES bool SignedRawBolt11Invoice_check_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
53730 export function SignedRawBolt11Invoice_check_signature(this_arg: bigint): boolean {
53731 if(!isWasmInitialized) {
53732 throw new Error("initializeWasm() must be awaited first!");
53734 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_check_signature(this_arg);
53735 return nativeResponseValue;
53737 // MUST_USE_RES struct LDKThirtyTwoBytes RawBolt11Invoice_signable_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53739 export function RawBolt11Invoice_signable_hash(this_arg: bigint): number {
53740 if(!isWasmInitialized) {
53741 throw new Error("initializeWasm() must be awaited first!");
53743 const nativeResponseValue = wasm.TS_RawBolt11Invoice_signable_hash(this_arg);
53744 return nativeResponseValue;
53746 // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_payment_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53748 export function RawBolt11Invoice_payment_hash(this_arg: bigint): bigint {
53749 if(!isWasmInitialized) {
53750 throw new Error("initializeWasm() must be awaited first!");
53752 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_hash(this_arg);
53753 return nativeResponseValue;
53755 // MUST_USE_RES struct LDKDescription RawBolt11Invoice_description(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53757 export function RawBolt11Invoice_description(this_arg: bigint): bigint {
53758 if(!isWasmInitialized) {
53759 throw new Error("initializeWasm() must be awaited first!");
53761 const nativeResponseValue = wasm.TS_RawBolt11Invoice_description(this_arg);
53762 return nativeResponseValue;
53764 // MUST_USE_RES struct LDKPayeePubKey RawBolt11Invoice_payee_pub_key(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53766 export function RawBolt11Invoice_payee_pub_key(this_arg: bigint): bigint {
53767 if(!isWasmInitialized) {
53768 throw new Error("initializeWasm() must be awaited first!");
53770 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payee_pub_key(this_arg);
53771 return nativeResponseValue;
53773 // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_description_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53775 export function RawBolt11Invoice_description_hash(this_arg: bigint): bigint {
53776 if(!isWasmInitialized) {
53777 throw new Error("initializeWasm() must be awaited first!");
53779 const nativeResponseValue = wasm.TS_RawBolt11Invoice_description_hash(this_arg);
53780 return nativeResponseValue;
53782 // MUST_USE_RES struct LDKExpiryTime RawBolt11Invoice_expiry_time(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53784 export function RawBolt11Invoice_expiry_time(this_arg: bigint): bigint {
53785 if(!isWasmInitialized) {
53786 throw new Error("initializeWasm() must be awaited first!");
53788 const nativeResponseValue = wasm.TS_RawBolt11Invoice_expiry_time(this_arg);
53789 return nativeResponseValue;
53791 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta RawBolt11Invoice_min_final_cltv_expiry_delta(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53793 export function RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
53794 if(!isWasmInitialized) {
53795 throw new Error("initializeWasm() must be awaited first!");
53797 const nativeResponseValue = wasm.TS_RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg);
53798 return nativeResponseValue;
53800 // MUST_USE_RES struct LDKCOption_ThirtyTwoBytesZ RawBolt11Invoice_payment_secret(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53802 export function RawBolt11Invoice_payment_secret(this_arg: bigint): bigint {
53803 if(!isWasmInitialized) {
53804 throw new Error("initializeWasm() must be awaited first!");
53806 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_secret(this_arg);
53807 return nativeResponseValue;
53809 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ RawBolt11Invoice_payment_metadata(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53811 export function RawBolt11Invoice_payment_metadata(this_arg: bigint): bigint {
53812 if(!isWasmInitialized) {
53813 throw new Error("initializeWasm() must be awaited first!");
53815 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_metadata(this_arg);
53816 return nativeResponseValue;
53818 // MUST_USE_RES struct LDKBolt11InvoiceFeatures RawBolt11Invoice_features(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53820 export function RawBolt11Invoice_features(this_arg: bigint): bigint {
53821 if(!isWasmInitialized) {
53822 throw new Error("initializeWasm() must be awaited first!");
53824 const nativeResponseValue = wasm.TS_RawBolt11Invoice_features(this_arg);
53825 return nativeResponseValue;
53827 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawBolt11Invoice_private_routes(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53829 export function RawBolt11Invoice_private_routes(this_arg: bigint): number {
53830 if(!isWasmInitialized) {
53831 throw new Error("initializeWasm() must be awaited first!");
53833 const nativeResponseValue = wasm.TS_RawBolt11Invoice_private_routes(this_arg);
53834 return nativeResponseValue;
53836 // MUST_USE_RES struct LDKCOption_u64Z RawBolt11Invoice_amount_pico_btc(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53838 export function RawBolt11Invoice_amount_pico_btc(this_arg: bigint): bigint {
53839 if(!isWasmInitialized) {
53840 throw new Error("initializeWasm() must be awaited first!");
53842 const nativeResponseValue = wasm.TS_RawBolt11Invoice_amount_pico_btc(this_arg);
53843 return nativeResponseValue;
53845 // MUST_USE_RES enum LDKCurrency RawBolt11Invoice_currency(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
53847 export function RawBolt11Invoice_currency(this_arg: bigint): Currency {
53848 if(!isWasmInitialized) {
53849 throw new Error("initializeWasm() must be awaited first!");
53851 const nativeResponseValue = wasm.TS_RawBolt11Invoice_currency(this_arg);
53852 return nativeResponseValue;
53854 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
53856 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): bigint {
53857 if(!isWasmInitialized) {
53858 throw new Error("initializeWasm() must be awaited first!");
53860 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
53861 return nativeResponseValue;
53863 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
53865 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): bigint {
53866 if(!isWasmInitialized) {
53867 throw new Error("initializeWasm() must be awaited first!");
53869 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
53870 return nativeResponseValue;
53872 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
53874 export function PositiveTimestamp_as_unix_timestamp(this_arg: bigint): bigint {
53875 if(!isWasmInitialized) {
53876 throw new Error("initializeWasm() must be awaited first!");
53878 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
53879 return nativeResponseValue;
53881 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
53883 export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): bigint {
53884 if(!isWasmInitialized) {
53885 throw new Error("initializeWasm() must be awaited first!");
53887 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
53888 return nativeResponseValue;
53890 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt11Invoice_signable_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53892 export function Bolt11Invoice_signable_hash(this_arg: bigint): number {
53893 if(!isWasmInitialized) {
53894 throw new Error("initializeWasm() must be awaited first!");
53896 const nativeResponseValue = wasm.TS_Bolt11Invoice_signable_hash(this_arg);
53897 return nativeResponseValue;
53899 // MUST_USE_RES struct LDKSignedRawBolt11Invoice Bolt11Invoice_into_signed_raw(struct LDKBolt11Invoice this_arg);
53901 export function Bolt11Invoice_into_signed_raw(this_arg: bigint): bigint {
53902 if(!isWasmInitialized) {
53903 throw new Error("initializeWasm() must be awaited first!");
53905 const nativeResponseValue = wasm.TS_Bolt11Invoice_into_signed_raw(this_arg);
53906 return nativeResponseValue;
53908 // MUST_USE_RES struct LDKCResult_NoneBolt11SemanticErrorZ Bolt11Invoice_check_signature(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53910 export function Bolt11Invoice_check_signature(this_arg: bigint): bigint {
53911 if(!isWasmInitialized) {
53912 throw new Error("initializeWasm() must be awaited first!");
53914 const nativeResponseValue = wasm.TS_Bolt11Invoice_check_signature(this_arg);
53915 return nativeResponseValue;
53917 // MUST_USE_RES struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ Bolt11Invoice_from_signed(struct LDKSignedRawBolt11Invoice signed_invoice);
53919 export function Bolt11Invoice_from_signed(signed_invoice: bigint): bigint {
53920 if(!isWasmInitialized) {
53921 throw new Error("initializeWasm() must be awaited first!");
53923 const nativeResponseValue = wasm.TS_Bolt11Invoice_from_signed(signed_invoice);
53924 return nativeResponseValue;
53926 // MUST_USE_RES uint64_t Bolt11Invoice_duration_since_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53928 export function Bolt11Invoice_duration_since_epoch(this_arg: bigint): bigint {
53929 if(!isWasmInitialized) {
53930 throw new Error("initializeWasm() must be awaited first!");
53932 const nativeResponseValue = wasm.TS_Bolt11Invoice_duration_since_epoch(this_arg);
53933 return nativeResponseValue;
53935 // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
53937 export function Bolt11Invoice_payment_hash(this_arg: bigint): number {
53938 if(!isWasmInitialized) {
53939 throw new Error("initializeWasm() must be awaited first!");
53941 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_hash(this_arg);
53942 return nativeResponseValue;
53944 // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53946 export function Bolt11Invoice_payee_pub_key(this_arg: bigint): number {
53947 if(!isWasmInitialized) {
53948 throw new Error("initializeWasm() must be awaited first!");
53950 const nativeResponseValue = wasm.TS_Bolt11Invoice_payee_pub_key(this_arg);
53951 return nativeResponseValue;
53953 // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_secret(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
53955 export function Bolt11Invoice_payment_secret(this_arg: bigint): number {
53956 if(!isWasmInitialized) {
53957 throw new Error("initializeWasm() must be awaited first!");
53959 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_secret(this_arg);
53960 return nativeResponseValue;
53962 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Bolt11Invoice_payment_metadata(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53964 export function Bolt11Invoice_payment_metadata(this_arg: bigint): bigint {
53965 if(!isWasmInitialized) {
53966 throw new Error("initializeWasm() must be awaited first!");
53968 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_metadata(this_arg);
53969 return nativeResponseValue;
53971 // MUST_USE_RES struct LDKBolt11InvoiceFeatures Bolt11Invoice_features(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53973 export function Bolt11Invoice_features(this_arg: bigint): bigint {
53974 if(!isWasmInitialized) {
53975 throw new Error("initializeWasm() must be awaited first!");
53977 const nativeResponseValue = wasm.TS_Bolt11Invoice_features(this_arg);
53978 return nativeResponseValue;
53980 // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_recover_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53982 export function Bolt11Invoice_recover_payee_pub_key(this_arg: bigint): number {
53983 if(!isWasmInitialized) {
53984 throw new Error("initializeWasm() must be awaited first!");
53986 const nativeResponseValue = wasm.TS_Bolt11Invoice_recover_payee_pub_key(this_arg);
53987 return nativeResponseValue;
53989 // MUST_USE_RES struct LDKCOption_u64Z Bolt11Invoice_expires_at(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
53991 export function Bolt11Invoice_expires_at(this_arg: bigint): bigint {
53992 if(!isWasmInitialized) {
53993 throw new Error("initializeWasm() must be awaited first!");
53995 const nativeResponseValue = wasm.TS_Bolt11Invoice_expires_at(this_arg);
53996 return nativeResponseValue;
53998 // MUST_USE_RES uint64_t Bolt11Invoice_expiry_time(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
54000 export function Bolt11Invoice_expiry_time(this_arg: bigint): bigint {
54001 if(!isWasmInitialized) {
54002 throw new Error("initializeWasm() must be awaited first!");
54004 const nativeResponseValue = wasm.TS_Bolt11Invoice_expiry_time(this_arg);
54005 return nativeResponseValue;
54007 // MUST_USE_RES uint64_t Bolt11Invoice_expiration_remaining_from_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t time);
54009 export function Bolt11Invoice_expiration_remaining_from_epoch(this_arg: bigint, time: bigint): bigint {
54010 if(!isWasmInitialized) {
54011 throw new Error("initializeWasm() must be awaited first!");
54013 const nativeResponseValue = wasm.TS_Bolt11Invoice_expiration_remaining_from_epoch(this_arg, time);
54014 return nativeResponseValue;
54016 // MUST_USE_RES bool Bolt11Invoice_would_expire(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t at_time);
54018 export function Bolt11Invoice_would_expire(this_arg: bigint, at_time: bigint): boolean {
54019 if(!isWasmInitialized) {
54020 throw new Error("initializeWasm() must be awaited first!");
54022 const nativeResponseValue = wasm.TS_Bolt11Invoice_would_expire(this_arg, at_time);
54023 return nativeResponseValue;
54025 // MUST_USE_RES uint64_t Bolt11Invoice_min_final_cltv_expiry_delta(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
54027 export function Bolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
54028 if(!isWasmInitialized) {
54029 throw new Error("initializeWasm() must be awaited first!");
54031 const nativeResponseValue = wasm.TS_Bolt11Invoice_min_final_cltv_expiry_delta(this_arg);
54032 return nativeResponseValue;
54034 // MUST_USE_RES struct LDKCVec_StrZ Bolt11Invoice_fallback_addresses(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
54036 export function Bolt11Invoice_fallback_addresses(this_arg: bigint): number {
54037 if(!isWasmInitialized) {
54038 throw new Error("initializeWasm() must be awaited first!");
54040 const nativeResponseValue = wasm.TS_Bolt11Invoice_fallback_addresses(this_arg);
54041 return nativeResponseValue;
54043 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Bolt11Invoice_private_routes(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
54045 export function Bolt11Invoice_private_routes(this_arg: bigint): number {
54046 if(!isWasmInitialized) {
54047 throw new Error("initializeWasm() must be awaited first!");
54049 const nativeResponseValue = wasm.TS_Bolt11Invoice_private_routes(this_arg);
54050 return nativeResponseValue;
54052 // MUST_USE_RES struct LDKCVec_RouteHintZ Bolt11Invoice_route_hints(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
54054 export function Bolt11Invoice_route_hints(this_arg: bigint): number {
54055 if(!isWasmInitialized) {
54056 throw new Error("initializeWasm() must be awaited first!");
54058 const nativeResponseValue = wasm.TS_Bolt11Invoice_route_hints(this_arg);
54059 return nativeResponseValue;
54061 // MUST_USE_RES enum LDKCurrency Bolt11Invoice_currency(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
54063 export function Bolt11Invoice_currency(this_arg: bigint): Currency {
54064 if(!isWasmInitialized) {
54065 throw new Error("initializeWasm() must be awaited first!");
54067 const nativeResponseValue = wasm.TS_Bolt11Invoice_currency(this_arg);
54068 return nativeResponseValue;
54070 // MUST_USE_RES struct LDKCOption_u64Z Bolt11Invoice_amount_milli_satoshis(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
54072 export function Bolt11Invoice_amount_milli_satoshis(this_arg: bigint): bigint {
54073 if(!isWasmInitialized) {
54074 throw new Error("initializeWasm() must be awaited first!");
54076 const nativeResponseValue = wasm.TS_Bolt11Invoice_amount_milli_satoshis(this_arg);
54077 return nativeResponseValue;
54079 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
54081 export function Description_new(description: number): bigint {
54082 if(!isWasmInitialized) {
54083 throw new Error("initializeWasm() must be awaited first!");
54085 const nativeResponseValue = wasm.TS_Description_new(description);
54086 return nativeResponseValue;
54088 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
54090 export function Description_into_inner(this_arg: bigint): number {
54091 if(!isWasmInitialized) {
54092 throw new Error("initializeWasm() must be awaited first!");
54094 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
54095 return nativeResponseValue;
54097 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
54099 export function ExpiryTime_from_seconds(seconds: bigint): bigint {
54100 if(!isWasmInitialized) {
54101 throw new Error("initializeWasm() must be awaited first!");
54103 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
54104 return nativeResponseValue;
54106 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
54108 export function ExpiryTime_from_duration(duration: bigint): bigint {
54109 if(!isWasmInitialized) {
54110 throw new Error("initializeWasm() must be awaited first!");
54112 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
54113 return nativeResponseValue;
54115 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
54117 export function ExpiryTime_as_seconds(this_arg: bigint): bigint {
54118 if(!isWasmInitialized) {
54119 throw new Error("initializeWasm() must be awaited first!");
54121 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
54122 return nativeResponseValue;
54124 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
54126 export function ExpiryTime_as_duration(this_arg: bigint): bigint {
54127 if(!isWasmInitialized) {
54128 throw new Error("initializeWasm() must be awaited first!");
54130 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
54131 return nativeResponseValue;
54133 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
54135 export function PrivateRoute_new(hops: bigint): bigint {
54136 if(!isWasmInitialized) {
54137 throw new Error("initializeWasm() must be awaited first!");
54139 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
54140 return nativeResponseValue;
54142 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
54144 export function PrivateRoute_into_inner(this_arg: bigint): bigint {
54145 if(!isWasmInitialized) {
54146 throw new Error("initializeWasm() must be awaited first!");
54148 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
54149 return nativeResponseValue;
54151 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
54153 export function CreationError_clone(orig: bigint): CreationError {
54154 if(!isWasmInitialized) {
54155 throw new Error("initializeWasm() must be awaited first!");
54157 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
54158 return nativeResponseValue;
54160 // enum LDKCreationError CreationError_description_too_long(void);
54162 export function CreationError_description_too_long(): CreationError {
54163 if(!isWasmInitialized) {
54164 throw new Error("initializeWasm() must be awaited first!");
54166 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
54167 return nativeResponseValue;
54169 // enum LDKCreationError CreationError_route_too_long(void);
54171 export function CreationError_route_too_long(): CreationError {
54172 if(!isWasmInitialized) {
54173 throw new Error("initializeWasm() must be awaited first!");
54175 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
54176 return nativeResponseValue;
54178 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
54180 export function CreationError_timestamp_out_of_bounds(): CreationError {
54181 if(!isWasmInitialized) {
54182 throw new Error("initializeWasm() must be awaited first!");
54184 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
54185 return nativeResponseValue;
54187 // enum LDKCreationError CreationError_invalid_amount(void);
54189 export function CreationError_invalid_amount(): CreationError {
54190 if(!isWasmInitialized) {
54191 throw new Error("initializeWasm() must be awaited first!");
54193 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
54194 return nativeResponseValue;
54196 // enum LDKCreationError CreationError_missing_route_hints(void);
54198 export function CreationError_missing_route_hints(): CreationError {
54199 if(!isWasmInitialized) {
54200 throw new Error("initializeWasm() must be awaited first!");
54202 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
54203 return nativeResponseValue;
54205 // enum LDKCreationError CreationError_min_final_cltv_expiry_delta_too_short(void);
54207 export function CreationError_min_final_cltv_expiry_delta_too_short(): CreationError {
54208 if(!isWasmInitialized) {
54209 throw new Error("initializeWasm() must be awaited first!");
54211 const nativeResponseValue = wasm.TS_CreationError_min_final_cltv_expiry_delta_too_short();
54212 return nativeResponseValue;
54214 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
54216 export function CreationError_eq(a: bigint, b: bigint): boolean {
54217 if(!isWasmInitialized) {
54218 throw new Error("initializeWasm() must be awaited first!");
54220 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
54221 return nativeResponseValue;
54223 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
54225 export function CreationError_to_str(o: bigint): number {
54226 if(!isWasmInitialized) {
54227 throw new Error("initializeWasm() must be awaited first!");
54229 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
54230 return nativeResponseValue;
54232 // enum LDKBolt11SemanticError Bolt11SemanticError_clone(const enum LDKBolt11SemanticError *NONNULL_PTR orig);
54234 export function Bolt11SemanticError_clone(orig: bigint): Bolt11SemanticError {
54235 if(!isWasmInitialized) {
54236 throw new Error("initializeWasm() must be awaited first!");
54238 const nativeResponseValue = wasm.TS_Bolt11SemanticError_clone(orig);
54239 return nativeResponseValue;
54241 // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_hash(void);
54243 export function Bolt11SemanticError_no_payment_hash(): Bolt11SemanticError {
54244 if(!isWasmInitialized) {
54245 throw new Error("initializeWasm() must be awaited first!");
54247 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_hash();
54248 return nativeResponseValue;
54250 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_hashes(void);
54252 export function Bolt11SemanticError_multiple_payment_hashes(): Bolt11SemanticError {
54253 if(!isWasmInitialized) {
54254 throw new Error("initializeWasm() must be awaited first!");
54256 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_hashes();
54257 return nativeResponseValue;
54259 // enum LDKBolt11SemanticError Bolt11SemanticError_no_description(void);
54261 export function Bolt11SemanticError_no_description(): Bolt11SemanticError {
54262 if(!isWasmInitialized) {
54263 throw new Error("initializeWasm() must be awaited first!");
54265 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_description();
54266 return nativeResponseValue;
54268 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_descriptions(void);
54270 export function Bolt11SemanticError_multiple_descriptions(): Bolt11SemanticError {
54271 if(!isWasmInitialized) {
54272 throw new Error("initializeWasm() must be awaited first!");
54274 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_descriptions();
54275 return nativeResponseValue;
54277 // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_secret(void);
54279 export function Bolt11SemanticError_no_payment_secret(): Bolt11SemanticError {
54280 if(!isWasmInitialized) {
54281 throw new Error("initializeWasm() must be awaited first!");
54283 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_secret();
54284 return nativeResponseValue;
54286 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_secrets(void);
54288 export function Bolt11SemanticError_multiple_payment_secrets(): Bolt11SemanticError {
54289 if(!isWasmInitialized) {
54290 throw new Error("initializeWasm() must be awaited first!");
54292 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_secrets();
54293 return nativeResponseValue;
54295 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_features(void);
54297 export function Bolt11SemanticError_invalid_features(): Bolt11SemanticError {
54298 if(!isWasmInitialized) {
54299 throw new Error("initializeWasm() must be awaited first!");
54301 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_features();
54302 return nativeResponseValue;
54304 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_recovery_id(void);
54306 export function Bolt11SemanticError_invalid_recovery_id(): Bolt11SemanticError {
54307 if(!isWasmInitialized) {
54308 throw new Error("initializeWasm() must be awaited first!");
54310 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_recovery_id();
54311 return nativeResponseValue;
54313 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_signature(void);
54315 export function Bolt11SemanticError_invalid_signature(): Bolt11SemanticError {
54316 if(!isWasmInitialized) {
54317 throw new Error("initializeWasm() must be awaited first!");
54319 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_signature();
54320 return nativeResponseValue;
54322 // enum LDKBolt11SemanticError Bolt11SemanticError_imprecise_amount(void);
54324 export function Bolt11SemanticError_imprecise_amount(): Bolt11SemanticError {
54325 if(!isWasmInitialized) {
54326 throw new Error("initializeWasm() must be awaited first!");
54328 const nativeResponseValue = wasm.TS_Bolt11SemanticError_imprecise_amount();
54329 return nativeResponseValue;
54331 // bool Bolt11SemanticError_eq(const enum LDKBolt11SemanticError *NONNULL_PTR a, const enum LDKBolt11SemanticError *NONNULL_PTR b);
54333 export function Bolt11SemanticError_eq(a: bigint, b: bigint): boolean {
54334 if(!isWasmInitialized) {
54335 throw new Error("initializeWasm() must be awaited first!");
54337 const nativeResponseValue = wasm.TS_Bolt11SemanticError_eq(a, b);
54338 return nativeResponseValue;
54340 // struct LDKStr Bolt11SemanticError_to_str(const enum LDKBolt11SemanticError *NONNULL_PTR o);
54342 export function Bolt11SemanticError_to_str(o: bigint): number {
54343 if(!isWasmInitialized) {
54344 throw new Error("initializeWasm() must be awaited first!");
54346 const nativeResponseValue = wasm.TS_Bolt11SemanticError_to_str(o);
54347 return nativeResponseValue;
54349 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
54351 export function SignOrCreationError_free(this_ptr: bigint): void {
54352 if(!isWasmInitialized) {
54353 throw new Error("initializeWasm() must be awaited first!");
54355 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
54356 // debug statements here
54358 // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
54360 export function SignOrCreationError_clone_ptr(arg: bigint): bigint {
54361 if(!isWasmInitialized) {
54362 throw new Error("initializeWasm() must be awaited first!");
54364 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
54365 return nativeResponseValue;
54367 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
54369 export function SignOrCreationError_clone(orig: bigint): bigint {
54370 if(!isWasmInitialized) {
54371 throw new Error("initializeWasm() must be awaited first!");
54373 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
54374 return nativeResponseValue;
54376 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
54378 export function SignOrCreationError_sign_error(): bigint {
54379 if(!isWasmInitialized) {
54380 throw new Error("initializeWasm() must be awaited first!");
54382 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
54383 return nativeResponseValue;
54385 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
54387 export function SignOrCreationError_creation_error(a: CreationError): bigint {
54388 if(!isWasmInitialized) {
54389 throw new Error("initializeWasm() must be awaited first!");
54391 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
54392 return nativeResponseValue;
54394 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
54396 export function SignOrCreationError_eq(a: bigint, b: bigint): boolean {
54397 if(!isWasmInitialized) {
54398 throw new Error("initializeWasm() must be awaited first!");
54400 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
54401 return nativeResponseValue;
54403 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
54405 export function SignOrCreationError_to_str(o: bigint): number {
54406 if(!isWasmInitialized) {
54407 throw new Error("initializeWasm() must be awaited first!");
54409 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
54410 return nativeResponseValue;
54412 // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ pay_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
54414 export function pay_invoice(invoice: bigint, retry_strategy: bigint, channelmanager: bigint): bigint {
54415 if(!isWasmInitialized) {
54416 throw new Error("initializeWasm() must be awaited first!");
54418 const nativeResponseValue = wasm.TS_pay_invoice(invoice, retry_strategy, channelmanager);
54419 return nativeResponseValue;
54421 // struct LDKCResult_NonePaymentErrorZ pay_invoice_with_id(const struct LDKBolt11Invoice *NONNULL_PTR invoice, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
54423 export function pay_invoice_with_id(invoice: bigint, payment_id: number, retry_strategy: bigint, channelmanager: bigint): bigint {
54424 if(!isWasmInitialized) {
54425 throw new Error("initializeWasm() must be awaited first!");
54427 const nativeResponseValue = wasm.TS_pay_invoice_with_id(invoice, payment_id, retry_strategy, channelmanager);
54428 return nativeResponseValue;
54430 // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ pay_zero_value_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msats, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
54432 export function pay_zero_value_invoice(invoice: bigint, amount_msats: bigint, retry_strategy: bigint, channelmanager: bigint): bigint {
54433 if(!isWasmInitialized) {
54434 throw new Error("initializeWasm() must be awaited first!");
54436 const nativeResponseValue = wasm.TS_pay_zero_value_invoice(invoice, amount_msats, retry_strategy, channelmanager);
54437 return nativeResponseValue;
54439 // struct LDKCResult_NonePaymentErrorZ pay_zero_value_invoice_with_id(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msats, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
54441 export function pay_zero_value_invoice_with_id(invoice: bigint, amount_msats: bigint, payment_id: number, retry_strategy: bigint, channelmanager: bigint): bigint {
54442 if(!isWasmInitialized) {
54443 throw new Error("initializeWasm() must be awaited first!");
54445 const nativeResponseValue = wasm.TS_pay_zero_value_invoice_with_id(invoice, amount_msats, payment_id, retry_strategy, channelmanager);
54446 return nativeResponseValue;
54448 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ preflight_probe_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKCOption_u64Z liquidity_limit_multiplier);
54450 export function preflight_probe_invoice(invoice: bigint, channelmanager: bigint, liquidity_limit_multiplier: bigint): bigint {
54451 if(!isWasmInitialized) {
54452 throw new Error("initializeWasm() must be awaited first!");
54454 const nativeResponseValue = wasm.TS_preflight_probe_invoice(invoice, channelmanager, liquidity_limit_multiplier);
54455 return nativeResponseValue;
54457 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ preflight_probe_zero_value_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msat, const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKCOption_u64Z liquidity_limit_multiplier);
54459 export function preflight_probe_zero_value_invoice(invoice: bigint, amount_msat: bigint, channelmanager: bigint, liquidity_limit_multiplier: bigint): bigint {
54460 if(!isWasmInitialized) {
54461 throw new Error("initializeWasm() must be awaited first!");
54463 const nativeResponseValue = wasm.TS_preflight_probe_zero_value_invoice(invoice, amount_msat, channelmanager, liquidity_limit_multiplier);
54464 return nativeResponseValue;
54466 // void PaymentError_free(struct LDKPaymentError this_ptr);
54468 export function PaymentError_free(this_ptr: bigint): void {
54469 if(!isWasmInitialized) {
54470 throw new Error("initializeWasm() must be awaited first!");
54472 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
54473 // debug statements here
54475 // uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
54477 export function PaymentError_clone_ptr(arg: bigint): bigint {
54478 if(!isWasmInitialized) {
54479 throw new Error("initializeWasm() must be awaited first!");
54481 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
54482 return nativeResponseValue;
54484 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
54486 export function PaymentError_clone(orig: bigint): bigint {
54487 if(!isWasmInitialized) {
54488 throw new Error("initializeWasm() must be awaited first!");
54490 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
54491 return nativeResponseValue;
54493 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
54495 export function PaymentError_invoice(a: number): bigint {
54496 if(!isWasmInitialized) {
54497 throw new Error("initializeWasm() must be awaited first!");
54499 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
54500 return nativeResponseValue;
54502 // struct LDKPaymentError PaymentError_sending(enum LDKRetryableSendFailure a);
54504 export function PaymentError_sending(a: RetryableSendFailure): bigint {
54505 if(!isWasmInitialized) {
54506 throw new Error("initializeWasm() must be awaited first!");
54508 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
54509 return nativeResponseValue;
54511 // bool PaymentError_eq(const struct LDKPaymentError *NONNULL_PTR a, const struct LDKPaymentError *NONNULL_PTR b);
54513 export function PaymentError_eq(a: bigint, b: bigint): boolean {
54514 if(!isWasmInitialized) {
54515 throw new Error("initializeWasm() must be awaited first!");
54517 const nativeResponseValue = wasm.TS_PaymentError_eq(a, b);
54518 return nativeResponseValue;
54520 // void ProbingError_free(struct LDKProbingError this_ptr);
54522 export function ProbingError_free(this_ptr: bigint): void {
54523 if(!isWasmInitialized) {
54524 throw new Error("initializeWasm() must be awaited first!");
54526 const nativeResponseValue = wasm.TS_ProbingError_free(this_ptr);
54527 // debug statements here
54529 // uint64_t ProbingError_clone_ptr(LDKProbingError *NONNULL_PTR arg);
54531 export function ProbingError_clone_ptr(arg: bigint): bigint {
54532 if(!isWasmInitialized) {
54533 throw new Error("initializeWasm() must be awaited first!");
54535 const nativeResponseValue = wasm.TS_ProbingError_clone_ptr(arg);
54536 return nativeResponseValue;
54538 // struct LDKProbingError ProbingError_clone(const struct LDKProbingError *NONNULL_PTR orig);
54540 export function ProbingError_clone(orig: bigint): bigint {
54541 if(!isWasmInitialized) {
54542 throw new Error("initializeWasm() must be awaited first!");
54544 const nativeResponseValue = wasm.TS_ProbingError_clone(orig);
54545 return nativeResponseValue;
54547 // struct LDKProbingError ProbingError_invoice(struct LDKStr a);
54549 export function ProbingError_invoice(a: number): bigint {
54550 if(!isWasmInitialized) {
54551 throw new Error("initializeWasm() must be awaited first!");
54553 const nativeResponseValue = wasm.TS_ProbingError_invoice(a);
54554 return nativeResponseValue;
54556 // struct LDKProbingError ProbingError_sending(struct LDKProbeSendFailure a);
54558 export function ProbingError_sending(a: bigint): bigint {
54559 if(!isWasmInitialized) {
54560 throw new Error("initializeWasm() must be awaited first!");
54562 const nativeResponseValue = wasm.TS_ProbingError_sending(a);
54563 return nativeResponseValue;
54565 // bool ProbingError_eq(const struct LDKProbingError *NONNULL_PTR a, const struct LDKProbingError *NONNULL_PTR b);
54567 export function ProbingError_eq(a: bigint, b: bigint): boolean {
54568 if(!isWasmInitialized) {
54569 throw new Error("initializeWasm() must be awaited first!");
54571 const nativeResponseValue = wasm.TS_ProbingError_eq(a, b);
54572 return nativeResponseValue;
54574 // 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);
54576 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 {
54577 if(!isWasmInitialized) {
54578 throw new Error("initializeWasm() must be awaited first!");
54580 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);
54581 return nativeResponseValue;
54583 // 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);
54585 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 {
54586 if(!isWasmInitialized) {
54587 throw new Error("initializeWasm() must be awaited first!");
54589 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);
54590 return nativeResponseValue;
54592 // 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);
54594 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 {
54595 if(!isWasmInitialized) {
54596 throw new Error("initializeWasm() must be awaited first!");
54598 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);
54599 return nativeResponseValue;
54601 // 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);
54603 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 {
54604 if(!isWasmInitialized) {
54605 throw new Error("initializeWasm() must be awaited first!");
54607 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);
54608 return nativeResponseValue;
54610 // 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);
54612 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 {
54613 if(!isWasmInitialized) {
54614 throw new Error("initializeWasm() must be awaited first!");
54616 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);
54617 return nativeResponseValue;
54619 // struct LDKCResult_SiPrefixBolt11ParseErrorZ SiPrefix_from_str(struct LDKStr s);
54621 export function SiPrefix_from_str(s: number): bigint {
54622 if(!isWasmInitialized) {
54623 throw new Error("initializeWasm() must be awaited first!");
54625 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
54626 return nativeResponseValue;
54628 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ Bolt11Invoice_from_str(struct LDKStr s);
54630 export function Bolt11Invoice_from_str(s: number): bigint {
54631 if(!isWasmInitialized) {
54632 throw new Error("initializeWasm() must be awaited first!");
54634 const nativeResponseValue = wasm.TS_Bolt11Invoice_from_str(s);
54635 return nativeResponseValue;
54637 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ SignedRawBolt11Invoice_from_str(struct LDKStr s);
54639 export function SignedRawBolt11Invoice_from_str(s: number): bigint {
54640 if(!isWasmInitialized) {
54641 throw new Error("initializeWasm() must be awaited first!");
54643 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_from_str(s);
54644 return nativeResponseValue;
54646 // struct LDKStr Bolt11ParseError_to_str(const struct LDKBolt11ParseError *NONNULL_PTR o);
54648 export function Bolt11ParseError_to_str(o: bigint): number {
54649 if(!isWasmInitialized) {
54650 throw new Error("initializeWasm() must be awaited first!");
54652 const nativeResponseValue = wasm.TS_Bolt11ParseError_to_str(o);
54653 return nativeResponseValue;
54655 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
54657 export function ParseOrSemanticError_to_str(o: bigint): number {
54658 if(!isWasmInitialized) {
54659 throw new Error("initializeWasm() must be awaited first!");
54661 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
54662 return nativeResponseValue;
54664 // struct LDKStr Bolt11Invoice_to_str(const struct LDKBolt11Invoice *NONNULL_PTR o);
54666 export function Bolt11Invoice_to_str(o: bigint): number {
54667 if(!isWasmInitialized) {
54668 throw new Error("initializeWasm() must be awaited first!");
54670 const nativeResponseValue = wasm.TS_Bolt11Invoice_to_str(o);
54671 return nativeResponseValue;
54673 // struct LDKStr SignedRawBolt11Invoice_to_str(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
54675 export function SignedRawBolt11Invoice_to_str(o: bigint): number {
54676 if(!isWasmInitialized) {
54677 throw new Error("initializeWasm() must be awaited first!");
54679 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_to_str(o);
54680 return nativeResponseValue;
54682 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
54684 export function Currency_to_str(o: bigint): number {
54685 if(!isWasmInitialized) {
54686 throw new Error("initializeWasm() must be awaited first!");
54688 const nativeResponseValue = wasm.TS_Currency_to_str(o);
54689 return nativeResponseValue;
54691 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
54693 export function SiPrefix_to_str(o: bigint): number {
54694 if(!isWasmInitialized) {
54695 throw new Error("initializeWasm() must be awaited first!");
54697 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
54698 return nativeResponseValue;
54702 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) {
54703 const weak: WeakRef<object>|undefined = js_objs[obj_ptr];
54704 if (weak == null || weak == undefined) {
54705 console.error("Got function call on unknown/free'd JS object!");
54706 throw new Error("Got function call on unknown/free'd JS object!");
54708 const obj = weak.deref();
54709 if (obj == null || obj == undefined) {
54710 console.error("Got function call on GC'd JS object!");
54711 throw new Error("Got function call on GC'd JS object!");
54715 case 0: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
54716 case 1: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
54717 case 2: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
54718 case 3: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
54719 case 4: fn = Object.getOwnPropertyDescriptor(obj, "provide_channel_parameters"); break;
54720 case 5: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
54721 case 6: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
54722 case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment"); break;
54723 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
54724 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
54725 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_htlc_transaction"); break;
54726 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
54727 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
54728 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_anchor_input"); break;
54729 case 14: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement_with_funding_key"); break;
54730 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54731 case 16: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
54732 case 17: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
54733 case 18: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
54734 case 19: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
54735 case 20: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
54736 case 21: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transactions"); break;
54737 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
54738 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
54739 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_node_id"); break;
54740 case 25: fn = Object.getOwnPropertyDescriptor(obj, "ecdh"); break;
54741 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
54742 case 27: fn = Object.getOwnPropertyDescriptor(obj, "sign_bolt12_invoice_request"); break;
54743 case 28: fn = Object.getOwnPropertyDescriptor(obj, "sign_bolt12_invoice"); break;
54744 case 29: fn = Object.getOwnPropertyDescriptor(obj, "sign_gossip_message"); break;
54745 case 30: fn = Object.getOwnPropertyDescriptor(obj, "generate_channel_keys_id"); break;
54746 case 31: fn = Object.getOwnPropertyDescriptor(obj, "derive_channel_signer"); break;
54747 case 32: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
54748 case 33: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
54749 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
54750 case 35: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
54751 case 36: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
54752 case 37: fn = Object.getOwnPropertyDescriptor(obj, "find_route_with_id"); break;
54753 case 38: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
54754 case 39: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
54755 case 40: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54756 case 41: fn = Object.getOwnPropertyDescriptor(obj, "tlv_type"); break;
54757 case 42: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54758 case 43: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
54759 case 44: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
54760 case 45: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
54761 case 46: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54762 case 47: fn = Object.getOwnPropertyDescriptor(obj, "remove"); break;
54763 case 48: fn = Object.getOwnPropertyDescriptor(obj, "list"); break;
54764 case 49: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
54765 case 50: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
54766 case 51: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
54767 case 52: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
54768 case 53: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
54769 case 54: fn = Object.getOwnPropertyDescriptor(obj, "read_lock"); break;
54770 case 55: fn = Object.getOwnPropertyDescriptor(obj, "write_lock"); break;
54771 case 56: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54772 case 57: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
54773 case 58: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
54774 case 59: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
54775 case 60: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
54776 case 61: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
54777 case 62: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
54778 case 63: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
54779 case 64: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
54780 case 65: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
54781 case 66: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
54782 case 67: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
54783 case 68: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
54784 case 69: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
54785 case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
54786 case 71: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
54787 case 72: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
54788 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
54789 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel_v2"); break;
54790 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
54791 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel_v2"); break;
54792 case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
54793 case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
54794 case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
54795 case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
54796 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
54797 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_input"); break;
54798 case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_output"); break;
54799 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_input"); break;
54800 case 85: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_output"); break;
54801 case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_complete"); break;
54802 case 87: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_signatures"); break;
54803 case 88: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_init_rbf"); break;
54804 case 89: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_ack_rbf"); break;
54805 case 90: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_abort"); break;
54806 case 91: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
54807 case 92: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
54808 case 93: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
54809 case 94: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
54810 case 95: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
54811 case 96: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
54812 case 97: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
54813 case 98: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
54814 case 99: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
54815 case 100: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
54816 case 101: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
54817 case 102: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
54818 case 103: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
54819 case 104: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
54820 case 105: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
54821 case 106: fn = Object.getOwnPropertyDescriptor(obj, "get_chain_hashes"); break;
54822 case 107: fn = Object.getOwnPropertyDescriptor(obj, "handle_message"); break;
54823 case 108: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_messages"); break;
54824 case 109: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
54825 case 110: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
54826 case 111: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
54827 case 112: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
54828 case 113: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
54829 case 114: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
54830 case 115: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
54831 case 116: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
54832 case 117: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
54833 case 118: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
54834 case 119: fn = Object.getOwnPropertyDescriptor(obj, "processing_queue_high"); break;
54835 case 120: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
54836 case 121: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
54837 case 122: fn = Object.getOwnPropertyDescriptor(obj, "handle_onion_message"); break;
54838 case 123: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
54839 case 124: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
54840 case 125: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
54841 case 126: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
54842 case 127: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
54843 case 128: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
54844 case 129: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
54845 case 130: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
54846 case 131: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
54847 case 132: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
54848 case 133: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
54849 case 134: fn = Object.getOwnPropertyDescriptor(obj, "read_custom_message"); break;
54850 case 135: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_custom_messages"); break;
54851 case 136: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
54852 case 137: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
54853 case 138: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
54854 case 139: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
54855 case 140: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
54856 case 141: fn = Object.getOwnPropertyDescriptor(obj, "find_path"); break;
54857 case 142: fn = Object.getOwnPropertyDescriptor(obj, "select_confirmed_utxos"); break;
54858 case 143: fn = Object.getOwnPropertyDescriptor(obj, "sign_tx"); break;
54859 case 144: fn = Object.getOwnPropertyDescriptor(obj, "list_confirmed_utxos"); break;
54860 case 145: fn = Object.getOwnPropertyDescriptor(obj, "get_change_script"); break;
54861 case 146: fn = Object.getOwnPropertyDescriptor(obj, "sign_tx"); break;
54863 console.error("Got unknown function call with id " + fn_id + " from C!");
54864 throw new Error("Got unknown function call with id " + fn_id + " from C!");
54866 if (fn == null || fn == undefined) {
54867 console.error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
54868 throw new Error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
54872 ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
54874 console.error("Got an exception calling function with id " + fn_id + "! This is fatal.");
54878 if (ret === undefined || ret === null) return BigInt(0);
54879 return BigInt(ret);