2 import * as version from './version.mjs';
3 import { UInt5, WitnessVersion } from './structs/CommonBase.mjs';
5 const imports: any = {};
8 var js_objs: Array<WeakRef<object>> = [];
9 var js_invoke: Function;
10 var getRandomValues: Function;
12 imports.wasi_snapshot_preview1 = {
13 "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number, bytes_written_ptr: number) => {
14 // This should generally only be used to print panic messages
15 const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
16 var bytes_written = 0;
17 for (var i = 0; i < iovec_array_len; i++) {
18 const bytes_view = new Uint8Array(wasm.memory.buffer, ptr_len_view[i*2], ptr_len_view[i*2+1]);
19 console.log("[fd " + fd + "]: " + String.fromCharCode(...bytes_view));
20 bytes_written += ptr_len_view[i*2+1]!;
22 const written_view = new Uint32Array(wasm.memory.buffer, bytes_written_ptr, 1);
23 written_view[0] = bytes_written;
26 "fd_close": (_fd: number) => {
27 // This is not generally called, but may be referenced in debug builds
28 console.log("wasi_snapshot_preview1:fd_close");
29 return 58; // Not Supported
31 "fd_seek": (_fd: number, _offset: bigint, _whence: number, _new_offset: number) => {
32 // This is not generally called, but may be referenced in debug builds
33 console.log("wasi_snapshot_preview1:fd_seek");
34 return 58; // Not Supported
36 "random_get": (buf_ptr: number, buf_len: number) => {
37 const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
41 "environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
42 // This is called before fd_write to format + print panic messages
43 const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
44 out_count_view[0] = 0;
45 const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
49 "environ_get": (_environ_ptr: number, _environ_buf_ptr: number) => {
50 // This is called before fd_write to format + print panic messages,
51 // but only if we have variables in environ_sizes_get, so shouldn't ever actually happen!
52 console.log("wasi_snapshot_preview1:environ_get");
53 return 58; // Note supported - we said there were 0 environment entries!
56 console.log("wasi_snapshot_preview1:proc_exit");
61 let isWasmInitialized: boolean = false;
63 async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
64 if (typeof crypto === "undefined") {
65 var crypto_import = (await import('crypto')).webcrypto;
66 getRandomValues = crypto_import.getRandomValues.bind(crypto_import);
68 getRandomValues = crypto.getRandomValues.bind(crypto);
71 wasm = wasmInstance.exports;
72 if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
73 throw new Error("Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
76 if (decodeString(wasm.TS_get_lib_version_string()) !== version.get_ldk_java_bindings_version())
77 throw new Error("Compiled LDK library and LDK class files do not match");
78 // Fetching the LDK versions from C also checks that the header and binaries match
79 const c_bindings_ver: number = wasm.TS_get_ldk_c_bindings_version();
80 const ldk_ver: number = wasm.TS_get_ldk_version();
81 if (c_bindings_ver == 0)
82 throw new Error("LDK version did not match the header we built against");
84 throw new Error("LDK C bindings version did not match the header we built against");
85 const c_bindings_version: string = decodeString(c_bindings_ver)
86 const ldk_version: string = decodeString(ldk_ver);
87 console.log("Loaded LDK-Java Bindings with LDK " + ldk_version + " and LDK-C-Bindings " + c_bindings_version);
89 isWasmInitialized = true;
92 const fn_list = ["uuuuuu", "buuuuu", "bbuuuu", "bbbuuu", "bbbbuu", "bbbbbu",
93 "bbbbbb", "ubuubu", "ubuuuu", "ubbuuu", "uubuuu", "uubbuu", "uububu", "ububuu"];
96 export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
97 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
98 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
99 await finishInitializeWasm(wasmInstance);
103 export async function initializeWasmFetch(uri: string) {
104 for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
105 const stream = fetch(uri);
106 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
107 await finishInitializeWasm(wasmInstance);
112 export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
113 const arr = new Uint8Array(inputArray.length);
114 for (var i = 0; i < inputArray.length; i++) {
115 arr[i] = inputArray[i]!.getVal();
121 export function WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): Uint8Array {
122 const arr = new Uint8Array(inputArray.length);
123 for (var i = 0; i < inputArray.length; i++) {
124 arr[i] = inputArray[i]!.getVal();
132 export function encodeUint128 (inputVal: bigint): number {
133 if (inputVal >= 0x10000000000000000000000000000000n) throw "U128s cannot exceed 128 bits";
134 const cArrayPointer = wasm.TS_malloc(16 + 8);
135 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
136 arrayLengthView[0] = BigInt(16);
137 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, 16);
138 for (var i = 0; i < 16; i++) arrayMemoryView[i] = Number((inputVal >> BigInt(i)*8n) & 0xffn);
139 return cArrayPointer;
142 export function encodeUint8Array (inputArray: Uint8Array|null): number {
143 if (inputArray == null) return 0;
144 const cArrayPointer = wasm.TS_malloc(inputArray.length + 8);
145 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
146 arrayLengthView[0] = BigInt(inputArray.length);
147 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
148 arrayMemoryView.set(inputArray);
149 return cArrayPointer;
152 export function encodeUint16Array (inputArray: Uint16Array|Array<number>|null): number {
153 if (inputArray == null) return 0;
154 const cArrayPointer = wasm.TS_malloc((inputArray.length + 4) * 2);
155 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
156 arrayLengthView[0] = BigInt(inputArray.length);
157 const arrayMemoryView = new Uint16Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
158 arrayMemoryView.set(inputArray);
159 return cArrayPointer;
162 export function encodeUint32Array (inputArray: Uint32Array|Array<number>|null): number {
163 if (inputArray == null) return 0;
164 const cArrayPointer = wasm.TS_malloc((inputArray.length + 2) * 4);
165 const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
166 arrayLengthView[0] = BigInt(inputArray.length);
167 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
168 arrayMemoryView.set(inputArray);
169 return cArrayPointer;
172 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>|null): number {
173 if (inputArray == null) return 0;
174 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 8);
175 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, inputArray.length + 1);
176 arrayMemoryView[0] = BigInt(inputArray.length);
177 arrayMemoryView.set(inputArray, 1);
178 return cArrayPointer;
182 export function check_arr_len(arr: Uint8Array|null, len: number): Uint8Array|null {
183 if (arr !== null && arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
188 export function check_16_arr_len(arr: Uint16Array|null, len: number): Uint16Array|null {
189 if (arr !== null && arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
194 export function getArrayLength(arrayPointer: number): number {
195 const arraySizeViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer, 1);
196 const len = arraySizeViewer[0]!;
197 if (len >= (2n ** 32n)) throw new Error("Bogus Array Size");
198 return Number(len % (2n ** 32n));
201 export function decodeUint128 (arrayPointer: number, free = true): bigint {
202 const arraySize = getArrayLength(arrayPointer);
203 if (arraySize != 16) throw "Need 16 bytes for a uint128";
204 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
206 for (var i = 0; i < 16; i++) {
208 val |= BigInt(actualArrayViewer[i]!);
211 wasm.TS_free(arrayPointer);
216 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
217 const arraySize = getArrayLength(arrayPointer);
218 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
219 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
220 // will free the underlying memory when it becomes unreachable instead of copying here.
221 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
222 const actualArray = actualArrayViewer.slice(0, arraySize);
224 wasm.TS_free(arrayPointer);
229 export function decodeUint16Array (arrayPointer: number, free = true): Uint16Array {
230 const arraySize = getArrayLength(arrayPointer);
231 const actualArrayViewer = new Uint16Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
232 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
233 // will free the underlying memory when it becomes unreachable instead of copying here.
234 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
235 const actualArray = actualArrayViewer.slice(0, arraySize);
237 wasm.TS_free(arrayPointer);
242 export function decodeUint64Array (arrayPointer: number, free = true): bigint[] {
243 const arraySize = getArrayLength(arrayPointer);
244 const actualArrayViewer = new BigUint64Array(
245 wasm.memory.buffer, // value
246 arrayPointer + 8, // offset (ignoring length bytes)
247 arraySize // uint32 count
249 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
250 // will free the underlying memory when it becomes unreachable instead of copying here.
251 const actualArray = new Array(arraySize);
252 for (var i = 0; i < arraySize; i++) actualArray[i] = actualArrayViewer[i];
254 wasm.TS_free(arrayPointer);
259 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
262 export function getU64ArrayElem(arrayPointer: number, idx: number): bigint {
263 const actualArrayViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
264 return actualArrayViewer[idx]!;
268 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
269 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
270 return actualArrayViewer[idx]!;
274 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
275 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
276 return actualArrayViewer[idx]!;
281 export function encodeString(str: string): number {
282 const charArray = new TextEncoder().encode(str);
283 return encodeUint8Array(charArray);
287 export function decodeString(stringPointer: number, free = true): string {
288 const arraySize = getArrayLength(stringPointer);
289 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 8, arraySize);
290 const result = new TextDecoder("utf-8").decode(memoryView);
293 wasm.TS_free(stringPointer);
299 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
300 /* @internal */ export function debugPrintRemainingAllocs() { }
303 * Whether this blinded HTLC is being failed backwards by the introduction node or a blinded node,
304 * which determines the failure message that should be used.
306 export enum BlindedFailure {
308 * This HTLC is being failed backwards by the introduction node, and thus should be failed with
309 [`msgs::UpdateFailHTLC`] and error code `0x8000|0x4000|24`.
311 LDKBlindedFailure_FromIntroductionNode,
313 * This HTLC is being failed backwards by a blinded node within the path, and thus should be
314 failed with [`msgs::UpdateFailMalformedHTLC`] and error code `0x8000|0x4000|24`.
316 LDKBlindedFailure_FromBlindedNode,
321 * Errors that may occur when converting a [`RawBolt11Invoice`] to a [`Bolt11Invoice`]. They relate to
322 * the requirements sections in BOLT #11
324 export enum Bolt11SemanticError {
326 * The invoice is missing the mandatory payment hash
328 LDKBolt11SemanticError_NoPaymentHash,
330 * The invoice has multiple payment hashes which isn't allowed
332 LDKBolt11SemanticError_MultiplePaymentHashes,
334 * No description or description hash are part of the invoice
336 LDKBolt11SemanticError_NoDescription,
338 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
340 LDKBolt11SemanticError_MultipleDescriptions,
342 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
345 LDKBolt11SemanticError_NoPaymentSecret,
347 * The invoice contains multiple payment secrets
349 LDKBolt11SemanticError_MultiplePaymentSecrets,
351 * The invoice's features are invalid
353 LDKBolt11SemanticError_InvalidFeatures,
355 * The recovery id doesn't fit the signature/pub key
357 LDKBolt11SemanticError_InvalidRecoveryId,
359 * The invoice's signature is invalid
361 LDKBolt11SemanticError_InvalidSignature,
363 * The invoice's amount was not a whole number of millisatoshis
365 LDKBolt11SemanticError_ImpreciseAmount,
370 * Error when interpreting a TLV stream as a specific type.
372 export enum Bolt12SemanticError {
374 * The current [`std::time::SystemTime`] is past the offer or invoice's expiration.
376 LDKBolt12SemanticError_AlreadyExpired,
378 * The provided chain hash does not correspond to a supported chain.
380 LDKBolt12SemanticError_UnsupportedChain,
382 * A chain was provided but was not expected.
384 LDKBolt12SemanticError_UnexpectedChain,
386 * An amount was expected but was missing.
388 LDKBolt12SemanticError_MissingAmount,
390 * The amount exceeded the total bitcoin supply.
392 LDKBolt12SemanticError_InvalidAmount,
394 * An amount was provided but was not sufficient in value.
396 LDKBolt12SemanticError_InsufficientAmount,
398 * An amount was provided but was not expected.
400 LDKBolt12SemanticError_UnexpectedAmount,
402 * A currency was provided that is not supported.
404 LDKBolt12SemanticError_UnsupportedCurrency,
406 * A feature was required but is unknown.
408 LDKBolt12SemanticError_UnknownRequiredFeatures,
410 * Features were provided but were not expected.
412 LDKBolt12SemanticError_UnexpectedFeatures,
414 * A required description was not provided.
416 LDKBolt12SemanticError_MissingDescription,
418 * A signing pubkey was not provided.
420 LDKBolt12SemanticError_MissingSigningPubkey,
422 * A signing pubkey was provided but a different one was expected.
424 LDKBolt12SemanticError_InvalidSigningPubkey,
426 * A signing pubkey was provided but was not expected.
428 LDKBolt12SemanticError_UnexpectedSigningPubkey,
430 * A quantity was expected but was missing.
432 LDKBolt12SemanticError_MissingQuantity,
434 * An unsupported quantity was provided.
436 LDKBolt12SemanticError_InvalidQuantity,
438 * A quantity or quantity bounds was provided but was not expected.
440 LDKBolt12SemanticError_UnexpectedQuantity,
442 * Metadata could not be used to verify the offers message.
444 LDKBolt12SemanticError_InvalidMetadata,
446 * Metadata was provided but was not expected.
448 LDKBolt12SemanticError_UnexpectedMetadata,
450 * Payer metadata was expected but was missing.
452 LDKBolt12SemanticError_MissingPayerMetadata,
454 * A payer id was expected but was missing.
456 LDKBolt12SemanticError_MissingPayerId,
458 * The payment id for a refund or request is already in use.
460 LDKBolt12SemanticError_DuplicatePaymentId,
462 * Blinded paths were expected but were missing.
464 LDKBolt12SemanticError_MissingPaths,
466 * The blinded payinfo given does not match the number of blinded path hops.
468 LDKBolt12SemanticError_InvalidPayInfo,
470 * An invoice creation time was expected but was missing.
472 LDKBolt12SemanticError_MissingCreationTime,
474 * An invoice payment hash was expected but was missing.
476 LDKBolt12SemanticError_MissingPaymentHash,
478 * A signature was expected but was missing.
480 LDKBolt12SemanticError_MissingSignature,
485 * An enum which can either contain a or not
487 export enum COption_NoneZ {
489 * When we're in this state, this COption_NoneZ contains a
491 LDKCOption_NoneZ_Some,
493 * When we're in this state, this COption_NoneZ contains nothing
495 LDKCOption_NoneZ_None,
500 * An enum representing the status of a channel monitor update persistence.
502 * These are generally used as the return value for an implementation of [`Persist`] which is used
503 * as the storage layer for a [`ChainMonitor`]. See the docs on [`Persist`] for a high-level
504 * explanation of how to handle different cases.
506 * While `UnrecoverableError` is provided as a failure variant, it is not truly \"handled\" on the
507 * calling side, and generally results in an immediate panic. For those who prefer to avoid
508 * panics, `InProgress` can be used and you can retry the update operation in the background or
511 * Note that channels should generally *not* be force-closed after a persistence failure.
512 * Force-closing with the latest [`ChannelMonitorUpdate`] applied may result in a transaction
513 * being broadcast which can only be spent by the latest [`ChannelMonitor`]! Thus, if the
514 * latest [`ChannelMonitor`] is not durably persisted anywhere and exists only in memory, naively
515 * calling [`ChannelManager::force_close_broadcasting_latest_txn`] *may result in loss of funds*!
517 * [`Persist`]: chainmonitor::Persist
518 * [`ChainMonitor`]: chainmonitor::ChainMonitor
519 * [`ChannelManager::force_close_broadcasting_latest_txn`]: crate::ln::channelmanager::ChannelManager::force_close_broadcasting_latest_txn
521 export enum ChannelMonitorUpdateStatus {
523 * The update has been durably persisted and all copies of the relevant [`ChannelMonitor`]
526 This includes performing any `fsync()` calls required to ensure the update is guaranteed to
527 be available on restart even if the application crashes.
529 LDKChannelMonitorUpdateStatus_Completed,
531 * Indicates that the update will happen asynchronously in the background or that a transient
532 failure occurred which is being retried in the background and will eventually complete.
534 This will \"freeze\" a channel, preventing us from revoking old states or submitting a new
535 commitment transaction to the counterparty. Once the update(s) which are `InProgress` have
536 been completed, a [`MonitorEvent::Completed`] can be used to restore the channel to an
539 Even when a channel has been \"frozen\", updates to the [`ChannelMonitor`] can continue to
540 occur (e.g. if an inbound HTLC which we forwarded was claimed upstream, resulting in us
541 attempting to claim it on this channel) and those updates must still be persisted.
543 No updates to the channel will be made which could invalidate other [`ChannelMonitor`]s
544 until a [`MonitorEvent::Completed`] is provided, even if you return no error on a later
545 monitor update for the same channel.
547 For deployments where a copy of [`ChannelMonitor`]s and other local state are backed up in
548 a remote location (with local copies persisted immediately), it is anticipated that all
549 updates will return [`InProgress`] until the remote copies could be updated.
551 Note that while fully asynchronous persistence of [`ChannelMonitor`] data is generally
552 reliable, this feature is considered beta, and a handful of edge-cases remain. Until the
553 remaining cases are fixed, in rare cases, *using this feature may lead to funds loss*.
555 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
557 LDKChannelMonitorUpdateStatus_InProgress,
559 * Indicates that an update has failed and will not complete at any point in the future.
561 Currently returning this variant will cause LDK to immediately panic to encourage immediate
562 shutdown. In the future this may be updated to disconnect peers and refuse to continue
563 normal operation without a panic.
565 Applications which wish to perform an orderly shutdown after failure should consider
566 returning [`InProgress`] instead and simply shut down without ever marking the update
569 [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
571 LDKChannelMonitorUpdateStatus_UnrecoverableError,
576 * Further information on the details of the channel shutdown.
577 * Upon channels being forced closed (i.e. commitment transaction confirmation detected
578 * by `ChainMonitor`), ChannelShutdownState will be set to `ShutdownComplete` or
579 * the channel will be removed shortly.
580 * Also note, that in normal operation, peers could disconnect at any of these states
581 * and require peer re-connection before making progress onto other states
583 export enum ChannelShutdownState {
585 * Channel has not sent or received a shutdown message.
587 LDKChannelShutdownState_NotShuttingDown,
589 * Local node has sent a shutdown message for this channel.
591 LDKChannelShutdownState_ShutdownInitiated,
593 * Shutdown message exchanges have concluded and the channels are in the midst of
594 resolving all existing open HTLCs before closing can continue.
596 LDKChannelShutdownState_ResolvingHTLCs,
598 * All HTLCs have been resolved, nodes are currently negotiating channel close onchain fee rates.
600 LDKChannelShutdownState_NegotiatingClosingFee,
602 * We've successfully negotiated a closing_signed dance. At this point `ChannelManager` is about
605 LDKChannelShutdownState_ShutdownComplete,
610 * An enum that represents the priority at which we want a transaction to confirm used for feerate
613 export enum ConfirmationTarget {
615 * We have some funds available on chain which we need to spend prior to some expiry time at
616 which point our counterparty may be able to steal them. Generally we have in the high tens
617 to low hundreds of blocks to get our transaction on-chain, but we shouldn't risk too low a
618 fee - this should be a relatively high priority feerate.
620 LDKConfirmationTarget_OnChainSweep,
622 * This is the lowest feerate we will allow our channel counterparty to have in an anchor
623 channel in order to close the channel if a channel party goes away.
625 This needs to be sufficient to get into the mempool when the channel needs to
626 be force-closed. Setting too high may result in force-closures if our counterparty attempts
627 to use a lower feerate. Because this is for anchor channels, we can always bump the feerate
628 later; the feerate here only needs to be sufficient to enter the mempool.
630 A good estimate is the expected mempool minimum at the time of force-closure. Obviously this
631 is not an estimate which is very easy to calculate because we do not know the future. Using
632 a simple long-term fee estimate or tracking of the mempool minimum is a good approach to
633 ensure you can always close the channel. A future change to Bitcoin's P2P network
634 (package relay) may obviate the need for this entirely.
636 LDKConfirmationTarget_MinAllowedAnchorChannelRemoteFee,
638 * The lowest feerate we will allow our channel counterparty to have in a non-anchor channel.
640 This is the feerate on the transaction which we (or our counterparty) will broadcast in
641 order to close the channel if a channel party goes away. Setting this value too high will
642 cause immediate force-closures in order to avoid having an unbroadcastable state.
644 This feerate represents the fee we pick now, which must be sufficient to enter a block at an
645 arbitrary time in the future. Obviously this is not an estimate which is very easy to
646 calculate. This can leave channels subject to being unable to close if feerates rise, and in
647 general you should prefer anchor channels to ensure you can increase the feerate when the
648 transactions need broadcasting.
650 Do note some fee estimators round up to the next full sat/vbyte (ie 250 sats per kw),
651 causing occasional issues with feerate disagreements between an initiator that wants a
652 feerate of 1.1 sat/vbyte and a receiver that wants 1.1 rounded up to 2. If your fee
653 estimator rounds subtracting 250 to your desired feerate here can help avoid this issue.
655 [`ChannelConfig::max_dust_htlc_exposure`]: crate::util::config::ChannelConfig::max_dust_htlc_exposure
657 LDKConfirmationTarget_MinAllowedNonAnchorChannelRemoteFee,
659 * This is the feerate on the transaction which we (or our counterparty) will broadcast in
660 order to close the channel if a channel party goes away.
662 This needs to be sufficient to get into the mempool when the channel needs to
663 be force-closed. Setting too low may result in force-closures. Because this is for anchor
664 channels, it can be a low value as we can always bump the feerate later.
666 A good estimate is the expected mempool minimum at the time of force-closure. Obviously this
667 is not an estimate which is very easy to calculate because we do not know the future. Using
668 a simple long-term fee estimate or tracking of the mempool minimum is a good approach to
669 ensure you can always close the channel. A future change to Bitcoin's P2P network
670 (package relay) may obviate the need for this entirely.
672 LDKConfirmationTarget_AnchorChannelFee,
674 * Lightning is built around the ability to broadcast a transaction in the future to close our
675 channel and claim all pending funds. In order to do so, non-anchor channels are built with
676 transactions which we need to be able to broadcast at some point in the future.
678 This feerate represents the fee we pick now, which must be sufficient to enter a block at an
679 arbitrary time in the future. Obviously this is not an estimate which is very easy to
680 calculate, so most lightning nodes use some relatively high-priority feerate using the
681 current mempool. This leaves channels subject to being unable to close if feerates rise, and
682 in general you should prefer anchor channels to ensure you can increase the feerate when the
683 transactions need broadcasting.
685 Since this should represent the feerate of a channel close that does not need fee
686 bumping, this is also used as an upper bound for our attempted feerate when doing cooperative
687 closure of any channel.
689 LDKConfirmationTarget_NonAnchorChannelFee,
691 * When cooperatively closing a channel, this is the minimum feerate we will accept.
692 Recommended at least within a day or so worth of blocks.
694 This will also be used when initiating a cooperative close of a channel. When closing a
695 channel you can override this fee by using
696 [`ChannelManager::close_channel_with_feerate_and_script`].
698 [`ChannelManager::close_channel_with_feerate_and_script`]: crate::ln::channelmanager::ChannelManager::close_channel_with_feerate_and_script
700 LDKConfirmationTarget_ChannelCloseMinimum,
705 * Errors that may occur when constructing a new [`RawBolt11Invoice`] or [`Bolt11Invoice`]
707 export enum CreationError {
709 * The supplied description string was longer than 639 __bytes__ (see [`Description::new`])
711 LDKCreationError_DescriptionTooLong,
713 * The specified route has too many hops and can't be encoded
715 LDKCreationError_RouteTooLong,
717 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
719 LDKCreationError_TimestampOutOfBounds,
721 * The supplied millisatoshi amount was greater than the total bitcoin supply.
723 LDKCreationError_InvalidAmount,
725 * Route hints were required for this invoice and were missing. Applies to
728 [phantom invoices]: crate::utils::create_phantom_invoice
730 LDKCreationError_MissingRouteHints,
732 * The provided `min_final_cltv_expiry_delta` was less than [`MIN_FINAL_CLTV_EXPIRY_DELTA`].
734 [`MIN_FINAL_CLTV_EXPIRY_DELTA`]: lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
736 LDKCreationError_MinFinalCltvExpiryDeltaTooShort,
741 * Enum representing the crypto currencies (or networks) supported by this library
743 export enum Currency {
751 LDKCurrency_BitcoinTestnet,
768 * Describes the type of HTLC claim as determined by analyzing the witness.
770 export enum HTLCClaim {
772 * Claims an offered output on a commitment transaction through the timeout path.
774 LDKHTLCClaim_OfferedTimeout,
776 * Claims an offered output on a commitment transaction through the success path.
778 LDKHTLCClaim_OfferedPreimage,
780 * Claims an accepted output on a commitment transaction through the timeout path.
782 LDKHTLCClaim_AcceptedTimeout,
784 * Claims an accepted output on a commitment transaction through the success path.
786 LDKHTLCClaim_AcceptedPreimage,
788 * Claims an offered/accepted output on a commitment transaction through the revocation path.
790 LDKHTLCClaim_Revocation,
795 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
797 export enum IOError {
799 LDKIOError_PermissionDenied,
800 LDKIOError_ConnectionRefused,
801 LDKIOError_ConnectionReset,
802 LDKIOError_ConnectionAborted,
803 LDKIOError_NotConnected,
804 LDKIOError_AddrInUse,
805 LDKIOError_AddrNotAvailable,
806 LDKIOError_BrokenPipe,
807 LDKIOError_AlreadyExists,
808 LDKIOError_WouldBlock,
809 LDKIOError_InvalidInput,
810 LDKIOError_InvalidData,
812 LDKIOError_WriteZero,
813 LDKIOError_Interrupted,
815 LDKIOError_UnexpectedEof,
820 * An enum representing the available verbosity levels of the logger.
824 * Designates extremely verbose information, including gossip-induced messages
828 * Designates very low priority, often extremely verbose, information
832 * Designates lower priority information
836 * Designates useful information
840 * Designates hazardous situations
844 * Designates very serious errors
851 * An enum representing the possible Bitcoin or test networks which we can run on
853 export enum Network {
855 * The main Bitcoin blockchain.
859 * The testnet3 blockchain.
863 * A local test blockchain.
867 * A blockchain on which blocks are signed instead of mined.
874 * The reason the payment failed. Used in [`Event::PaymentFailed`].
876 export enum PaymentFailureReason {
878 * The intended recipient rejected our payment.
880 LDKPaymentFailureReason_RecipientRejected,
882 * The user chose to abandon this payment by calling [`ChannelManager::abandon_payment`].
884 [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
886 LDKPaymentFailureReason_UserAbandoned,
888 * We exhausted all of our retry attempts while trying to send the payment, or we
889 exhausted the [`Retry::Timeout`] if the user set one. If at any point a retry
890 attempt failed while being forwarded along the path, an [`Event::PaymentPathFailed`] will
891 have come before this.
893 [`Retry::Timeout`]: crate::ln::channelmanager::Retry::Timeout
895 LDKPaymentFailureReason_RetriesExhausted,
897 * The payment expired while retrying, based on the provided
898 [`PaymentParameters::expiry_time`].
900 [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
902 LDKPaymentFailureReason_PaymentExpired,
904 * We failed to find a route while retrying the payment.
906 LDKPaymentFailureReason_RouteNotFound,
908 * This error should generally never happen. This likely means that there is a problem with
911 LDKPaymentFailureReason_UnexpectedError,
916 * Specifies the recipient of an invoice.
918 * This indicates to [`NodeSigner::sign_invoice`] what node secret key should be used to sign
921 export enum Recipient {
923 * The invoice should be signed with the local node secret key.
927 * The invoice should be signed with the phantom node secret key. This secret key must be the
928 same for all nodes participating in the [phantom node payment].
930 [phantom node payment]: PhantomKeysManager
932 LDKRecipient_PhantomNode,
937 * Indicates an immediate error on [`ChannelManager::send_payment`]. Further errors may be
938 * surfaced later via [`Event::PaymentPathFailed`] and [`Event::PaymentFailed`].
940 * [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
941 * [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
942 * [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
944 export enum RetryableSendFailure {
946 * The provided [`PaymentParameters::expiry_time`] indicated that the payment has expired. Note
947 that this error is *not* caused by [`Retry::Timeout`].
949 [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
951 LDKRetryableSendFailure_PaymentExpired,
953 * We were unable to find a route to the destination.
955 LDKRetryableSendFailure_RouteNotFound,
957 * Indicates that a payment for the provided [`PaymentId`] is already in-flight and has not
958 yet completed (i.e. generated an [`Event::PaymentSent`] or [`Event::PaymentFailed`]).
960 [`PaymentId`]: crate::ln::channelmanager::PaymentId
961 [`Event::PaymentSent`]: crate::events::Event::PaymentSent
962 [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
964 LDKRetryableSendFailure_DuplicatePayment,
969 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
971 export enum Secp256k1Error {
973 * Signature failed verification
975 LDKSecp256k1Error_IncorrectSignature,
977 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
979 LDKSecp256k1Error_InvalidMessage,
983 LDKSecp256k1Error_InvalidPublicKey,
987 LDKSecp256k1Error_InvalidSignature,
991 LDKSecp256k1Error_InvalidSecretKey,
995 LDKSecp256k1Error_InvalidSharedSecret,
999 LDKSecp256k1Error_InvalidRecoveryId,
1001 * Invalid tweak for add_assign or mul_assign
1003 LDKSecp256k1Error_InvalidTweak,
1005 * Didn't pass enough memory to context creation with preallocated memory
1007 LDKSecp256k1Error_NotEnoughMemory,
1009 * Bad set of public keys.
1011 LDKSecp256k1Error_InvalidPublicKeySum,
1013 * The only valid parity values are 0 or 1.
1015 LDKSecp256k1Error_InvalidParityValue,
1020 * SI prefixes for the human readable part
1022 export enum SiPrefix {
1043 * [`SocketAddress`] error variants
1045 export enum SocketAddressParseError {
1047 * Socket address (IPv4/IPv6) parsing error
1049 LDKSocketAddressParseError_SocketAddrParse,
1051 * Invalid input format
1053 LDKSocketAddressParseError_InvalidInput,
1057 LDKSocketAddressParseError_InvalidPort,
1059 * Invalid onion v3 address
1061 LDKSocketAddressParseError_InvalidOnionV3,
1066 * An error when accessing the chain via [`UtxoLookup`].
1068 export enum UtxoLookupError {
1070 * The requested chain is unknown.
1072 LDKUtxoLookupError_UnknownChain,
1074 * The requested transaction doesn't exist or hasn't confirmed.
1076 LDKUtxoLookupError_UnknownTx,
1079 // struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing)
1081 export function BigEndianScalar_get_bytes(thing: bigint): number {
1082 if(!isWasmInitialized) {
1083 throw new Error("initializeWasm() must be awaited first!");
1085 const nativeResponseValue = wasm.TS_BigEndianScalar_get_bytes(thing);
1086 return nativeResponseValue;
1088 // static void BigEndianScalar_free (struct LDKBigEndianScalar thing)
1090 export function BigEndianScalar_free(thing: bigint): void {
1091 if(!isWasmInitialized) {
1092 throw new Error("initializeWasm() must be awaited first!");
1094 const nativeResponseValue = wasm.TS_BigEndianScalar_free(thing);
1095 // debug statements here
1098 export class LDKBech32Error {
1099 protected constructor() {}
1102 export function LDKBech32Error_ty_from_ptr(ptr: bigint): number {
1103 if(!isWasmInitialized) {
1104 throw new Error("initializeWasm() must be awaited first!");
1106 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
1107 return nativeResponseValue;
1110 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: bigint): number {
1111 if(!isWasmInitialized) {
1112 throw new Error("initializeWasm() must be awaited first!");
1114 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
1115 return nativeResponseValue;
1118 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: bigint): number {
1119 if(!isWasmInitialized) {
1120 throw new Error("initializeWasm() must be awaited first!");
1122 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
1123 return nativeResponseValue;
1126 export class LDKCOption_u64Z {
1127 protected constructor() {}
1130 export function LDKCOption_u64Z_ty_from_ptr(ptr: bigint): number {
1131 if(!isWasmInitialized) {
1132 throw new Error("initializeWasm() must be awaited first!");
1134 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1135 return nativeResponseValue;
1138 export function LDKCOption_u64Z_Some_get_some(ptr: bigint): bigint {
1139 if(!isWasmInitialized) {
1140 throw new Error("initializeWasm() must be awaited first!");
1142 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1143 return nativeResponseValue;
1145 // struct LDKRefund CResult_RefundBolt12ParseErrorZ_get_ok(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner);
1147 export function CResult_RefundBolt12ParseErrorZ_get_ok(owner: bigint): bigint {
1148 if(!isWasmInitialized) {
1149 throw new Error("initializeWasm() must be awaited first!");
1151 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_get_ok(owner);
1152 return nativeResponseValue;
1154 // struct LDKBolt12ParseError CResult_RefundBolt12ParseErrorZ_get_err(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner);
1156 export function CResult_RefundBolt12ParseErrorZ_get_err(owner: bigint): bigint {
1157 if(!isWasmInitialized) {
1158 throw new Error("initializeWasm() must be awaited first!");
1160 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_get_err(owner);
1161 return nativeResponseValue;
1164 export class LDKRetry {
1165 protected constructor() {}
1168 export function LDKRetry_ty_from_ptr(ptr: bigint): number {
1169 if(!isWasmInitialized) {
1170 throw new Error("initializeWasm() must be awaited first!");
1172 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
1173 return nativeResponseValue;
1176 export function LDKRetry_Attempts_get_attempts(ptr: bigint): number {
1177 if(!isWasmInitialized) {
1178 throw new Error("initializeWasm() must be awaited first!");
1180 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
1181 return nativeResponseValue;
1184 export class LDKDecodeError {
1185 protected constructor() {}
1188 export function LDKDecodeError_ty_from_ptr(ptr: bigint): number {
1189 if(!isWasmInitialized) {
1190 throw new Error("initializeWasm() must be awaited first!");
1192 const nativeResponseValue = wasm.TS_LDKDecodeError_ty_from_ptr(ptr);
1193 return nativeResponseValue;
1196 export function LDKDecodeError_Io_get_io(ptr: bigint): IOError {
1197 if(!isWasmInitialized) {
1198 throw new Error("initializeWasm() must be awaited first!");
1200 const nativeResponseValue = wasm.TS_LDKDecodeError_Io_get_io(ptr);
1201 return nativeResponseValue;
1203 // struct LDKRetry CResult_RetryDecodeErrorZ_get_ok(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR owner);
1205 export function CResult_RetryDecodeErrorZ_get_ok(owner: bigint): bigint {
1206 if(!isWasmInitialized) {
1207 throw new Error("initializeWasm() must be awaited first!");
1209 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_get_ok(owner);
1210 return nativeResponseValue;
1212 // struct LDKDecodeError CResult_RetryDecodeErrorZ_get_err(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR owner);
1214 export function CResult_RetryDecodeErrorZ_get_err(owner: bigint): bigint {
1215 if(!isWasmInitialized) {
1216 throw new Error("initializeWasm() must be awaited first!");
1218 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_get_err(owner);
1219 return nativeResponseValue;
1222 export class LDKAPIError {
1223 protected constructor() {}
1226 export function LDKAPIError_ty_from_ptr(ptr: bigint): number {
1227 if(!isWasmInitialized) {
1228 throw new Error("initializeWasm() must be awaited first!");
1230 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
1231 return nativeResponseValue;
1234 export function LDKAPIError_APIMisuseError_get_err(ptr: bigint): number {
1235 if(!isWasmInitialized) {
1236 throw new Error("initializeWasm() must be awaited first!");
1238 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
1239 return nativeResponseValue;
1242 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: bigint): number {
1243 if(!isWasmInitialized) {
1244 throw new Error("initializeWasm() must be awaited first!");
1246 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
1247 return nativeResponseValue;
1250 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: bigint): number {
1251 if(!isWasmInitialized) {
1252 throw new Error("initializeWasm() must be awaited first!");
1254 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
1255 return nativeResponseValue;
1258 export function LDKAPIError_InvalidRoute_get_err(ptr: bigint): number {
1259 if(!isWasmInitialized) {
1260 throw new Error("initializeWasm() must be awaited first!");
1262 const nativeResponseValue = wasm.TS_LDKAPIError_InvalidRoute_get_err(ptr);
1263 return nativeResponseValue;
1266 export function LDKAPIError_ChannelUnavailable_get_err(ptr: bigint): number {
1267 if(!isWasmInitialized) {
1268 throw new Error("initializeWasm() must be awaited first!");
1270 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
1271 return nativeResponseValue;
1274 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: bigint): bigint {
1275 if(!isWasmInitialized) {
1276 throw new Error("initializeWasm() must be awaited first!");
1278 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
1279 return nativeResponseValue;
1281 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
1283 export function CResult_NoneAPIErrorZ_get_ok(owner: bigint): void {
1284 if(!isWasmInitialized) {
1285 throw new Error("initializeWasm() must be awaited first!");
1287 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
1288 // debug statements here
1290 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
1292 export function CResult_NoneAPIErrorZ_get_err(owner: bigint): bigint {
1293 if(!isWasmInitialized) {
1294 throw new Error("initializeWasm() must be awaited first!");
1296 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
1297 return nativeResponseValue;
1300 export class LDKCOption_ThirtyTwoBytesZ {
1301 protected constructor() {}
1304 export function LDKCOption_ThirtyTwoBytesZ_ty_from_ptr(ptr: bigint): number {
1305 if(!isWasmInitialized) {
1306 throw new Error("initializeWasm() must be awaited first!");
1308 const nativeResponseValue = wasm.TS_LDKCOption_ThirtyTwoBytesZ_ty_from_ptr(ptr);
1309 return nativeResponseValue;
1312 export function LDKCOption_ThirtyTwoBytesZ_Some_get_some(ptr: bigint): number {
1313 if(!isWasmInitialized) {
1314 throw new Error("initializeWasm() must be awaited first!");
1316 const nativeResponseValue = wasm.TS_LDKCOption_ThirtyTwoBytesZ_Some_get_some(ptr);
1317 return nativeResponseValue;
1320 export class LDKCOption_CVec_u8ZZ {
1321 protected constructor() {}
1324 export function LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr: bigint): number {
1325 if(!isWasmInitialized) {
1326 throw new Error("initializeWasm() must be awaited first!");
1328 const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_ty_from_ptr(ptr);
1329 return nativeResponseValue;
1332 export function LDKCOption_CVec_u8ZZ_Some_get_some(ptr: bigint): number {
1333 if(!isWasmInitialized) {
1334 throw new Error("initializeWasm() must be awaited first!");
1336 const nativeResponseValue = wasm.TS_LDKCOption_CVec_u8ZZ_Some_get_some(ptr);
1337 return nativeResponseValue;
1339 // struct LDKRecipientOnionFields CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
1341 export function CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner: bigint): bigint {
1342 if(!isWasmInitialized) {
1343 throw new Error("initializeWasm() must be awaited first!");
1345 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner);
1346 return nativeResponseValue;
1348 // struct LDKDecodeError CResult_RecipientOnionFieldsDecodeErrorZ_get_err(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner);
1350 export function CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner: bigint): bigint {
1351 if(!isWasmInitialized) {
1352 throw new Error("initializeWasm() must be awaited first!");
1354 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner);
1355 return nativeResponseValue;
1357 // uint64_t C2Tuple_u64CVec_u8ZZ_get_a(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR owner);
1359 export function C2Tuple_u64CVec_u8ZZ_get_a(owner: bigint): bigint {
1360 if(!isWasmInitialized) {
1361 throw new Error("initializeWasm() must be awaited first!");
1363 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_get_a(owner);
1364 return nativeResponseValue;
1366 // struct LDKCVec_u8Z C2Tuple_u64CVec_u8ZZ_get_b(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR owner);
1368 export function C2Tuple_u64CVec_u8ZZ_get_b(owner: bigint): number {
1369 if(!isWasmInitialized) {
1370 throw new Error("initializeWasm() must be awaited first!");
1372 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_get_b(owner);
1373 return nativeResponseValue;
1375 // struct LDKRecipientOnionFields CResult_RecipientOnionFieldsNoneZ_get_ok(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR owner);
1377 export function CResult_RecipientOnionFieldsNoneZ_get_ok(owner: bigint): bigint {
1378 if(!isWasmInitialized) {
1379 throw new Error("initializeWasm() must be awaited first!");
1381 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_get_ok(owner);
1382 return nativeResponseValue;
1384 // void CResult_RecipientOnionFieldsNoneZ_get_err(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR owner);
1386 export function CResult_RecipientOnionFieldsNoneZ_get_err(owner: bigint): void {
1387 if(!isWasmInitialized) {
1388 throw new Error("initializeWasm() must be awaited first!");
1390 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_get_err(owner);
1391 // debug statements here
1394 export class LDKCOption_CVec_ThirtyTwoBytesZZ {
1395 protected constructor() {}
1398 export function LDKCOption_CVec_ThirtyTwoBytesZZ_ty_from_ptr(ptr: bigint): number {
1399 if(!isWasmInitialized) {
1400 throw new Error("initializeWasm() must be awaited first!");
1402 const nativeResponseValue = wasm.TS_LDKCOption_CVec_ThirtyTwoBytesZZ_ty_from_ptr(ptr);
1403 return nativeResponseValue;
1406 export function LDKCOption_CVec_ThirtyTwoBytesZZ_Some_get_some(ptr: bigint): number {
1407 if(!isWasmInitialized) {
1408 throw new Error("initializeWasm() must be awaited first!");
1410 const nativeResponseValue = wasm.TS_LDKCOption_CVec_ThirtyTwoBytesZZ_Some_get_some(ptr);
1411 return nativeResponseValue;
1413 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesNoneZ_get_ok(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR owner);
1415 export function CResult_ThirtyTwoBytesNoneZ_get_ok(owner: bigint): number {
1416 if(!isWasmInitialized) {
1417 throw new Error("initializeWasm() must be awaited first!");
1419 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_get_ok(owner);
1420 return nativeResponseValue;
1422 // void CResult_ThirtyTwoBytesNoneZ_get_err(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR owner);
1424 export function CResult_ThirtyTwoBytesNoneZ_get_err(owner: bigint): void {
1425 if(!isWasmInitialized) {
1426 throw new Error("initializeWasm() must be awaited first!");
1428 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_get_err(owner);
1429 // debug statements here
1431 // struct LDKBlindedPayInfo CResult_BlindedPayInfoDecodeErrorZ_get_ok(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
1433 export function CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
1434 if(!isWasmInitialized) {
1435 throw new Error("initializeWasm() must be awaited first!");
1437 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner);
1438 return nativeResponseValue;
1440 // struct LDKDecodeError CResult_BlindedPayInfoDecodeErrorZ_get_err(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner);
1442 export function CResult_BlindedPayInfoDecodeErrorZ_get_err(owner: bigint): bigint {
1443 if(!isWasmInitialized) {
1444 throw new Error("initializeWasm() must be awaited first!");
1446 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_get_err(owner);
1447 return nativeResponseValue;
1449 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1451 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1452 if(!isWasmInitialized) {
1453 throw new Error("initializeWasm() must be awaited first!");
1455 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
1456 return nativeResponseValue;
1458 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1460 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1461 if(!isWasmInitialized) {
1462 throw new Error("initializeWasm() must be awaited first!");
1464 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
1465 return nativeResponseValue;
1467 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1469 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1470 if(!isWasmInitialized) {
1471 throw new Error("initializeWasm() must be awaited first!");
1473 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
1474 return nativeResponseValue;
1476 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1478 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1479 if(!isWasmInitialized) {
1480 throw new Error("initializeWasm() must be awaited first!");
1482 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
1483 return nativeResponseValue;
1486 export class LDKSpendableOutputDescriptor {
1487 protected constructor() {}
1490 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: bigint): number {
1491 if(!isWasmInitialized) {
1492 throw new Error("initializeWasm() must be awaited first!");
1494 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1495 return nativeResponseValue;
1498 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: bigint): bigint {
1499 if(!isWasmInitialized) {
1500 throw new Error("initializeWasm() must be awaited first!");
1502 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1503 return nativeResponseValue;
1506 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: bigint): bigint {
1507 if(!isWasmInitialized) {
1508 throw new Error("initializeWasm() must be awaited first!");
1510 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1511 return nativeResponseValue;
1514 export function LDKSpendableOutputDescriptor_StaticOutput_get_channel_keys_id(ptr: bigint): number {
1515 if(!isWasmInitialized) {
1516 throw new Error("initializeWasm() must be awaited first!");
1518 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_channel_keys_id(ptr);
1519 return nativeResponseValue;
1522 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: bigint): bigint {
1523 if(!isWasmInitialized) {
1524 throw new Error("initializeWasm() must be awaited first!");
1526 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1527 return nativeResponseValue;
1530 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: bigint): bigint {
1531 if(!isWasmInitialized) {
1532 throw new Error("initializeWasm() must be awaited first!");
1534 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1535 return nativeResponseValue;
1537 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1539 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1540 if(!isWasmInitialized) {
1541 throw new Error("initializeWasm() must be awaited first!");
1543 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
1544 return nativeResponseValue;
1546 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
1548 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1549 if(!isWasmInitialized) {
1550 throw new Error("initializeWasm() must be awaited first!");
1552 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
1553 return nativeResponseValue;
1556 export class LDKCOption_u32Z {
1557 protected constructor() {}
1560 export function LDKCOption_u32Z_ty_from_ptr(ptr: bigint): number {
1561 if(!isWasmInitialized) {
1562 throw new Error("initializeWasm() must be awaited first!");
1564 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
1565 return nativeResponseValue;
1568 export function LDKCOption_u32Z_Some_get_some(ptr: bigint): number {
1569 if(!isWasmInitialized) {
1570 throw new Error("initializeWasm() must be awaited first!");
1572 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
1573 return nativeResponseValue;
1575 // struct LDKCVec_u8Z C2Tuple_CVec_u8Zu64Z_get_a(LDKC2Tuple_CVec_u8Zu64Z *NONNULL_PTR owner);
1577 export function C2Tuple_CVec_u8Zu64Z_get_a(owner: bigint): number {
1578 if(!isWasmInitialized) {
1579 throw new Error("initializeWasm() must be awaited first!");
1581 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_get_a(owner);
1582 return nativeResponseValue;
1584 // uint64_t C2Tuple_CVec_u8Zu64Z_get_b(LDKC2Tuple_CVec_u8Zu64Z *NONNULL_PTR owner);
1586 export function C2Tuple_CVec_u8Zu64Z_get_b(owner: bigint): bigint {
1587 if(!isWasmInitialized) {
1588 throw new Error("initializeWasm() must be awaited first!");
1590 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_get_b(owner);
1591 return nativeResponseValue;
1593 // struct LDKC2Tuple_CVec_u8Zu64Z CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_ok(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR owner);
1595 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_ok(owner: bigint): bigint {
1596 if(!isWasmInitialized) {
1597 throw new Error("initializeWasm() must be awaited first!");
1599 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_ok(owner);
1600 return nativeResponseValue;
1602 // void CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_err(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR owner);
1604 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_err(owner: bigint): void {
1605 if(!isWasmInitialized) {
1606 throw new Error("initializeWasm() must be awaited first!");
1608 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_get_err(owner);
1609 // debug statements here
1611 // struct LDKChannelDerivationParameters CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR owner);
1613 export function CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
1614 if(!isWasmInitialized) {
1615 throw new Error("initializeWasm() must be awaited first!");
1617 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(owner);
1618 return nativeResponseValue;
1620 // struct LDKDecodeError CResult_ChannelDerivationParametersDecodeErrorZ_get_err(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR owner);
1622 export function CResult_ChannelDerivationParametersDecodeErrorZ_get_err(owner: bigint): bigint {
1623 if(!isWasmInitialized) {
1624 throw new Error("initializeWasm() must be awaited first!");
1626 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_err(owner);
1627 return nativeResponseValue;
1629 // struct LDKHTLCDescriptor CResult_HTLCDescriptorDecodeErrorZ_get_ok(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR owner);
1631 export function CResult_HTLCDescriptorDecodeErrorZ_get_ok(owner: bigint): bigint {
1632 if(!isWasmInitialized) {
1633 throw new Error("initializeWasm() must be awaited first!");
1635 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_get_ok(owner);
1636 return nativeResponseValue;
1638 // struct LDKDecodeError CResult_HTLCDescriptorDecodeErrorZ_get_err(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR owner);
1640 export function CResult_HTLCDescriptorDecodeErrorZ_get_err(owner: bigint): bigint {
1641 if(!isWasmInitialized) {
1642 throw new Error("initializeWasm() must be awaited first!");
1644 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_get_err(owner);
1645 return nativeResponseValue;
1647 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1649 export function CResult_NoneNoneZ_get_ok(owner: bigint): void {
1650 if(!isWasmInitialized) {
1651 throw new Error("initializeWasm() must be awaited first!");
1653 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
1654 // debug statements here
1656 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1658 export function CResult_NoneNoneZ_get_err(owner: bigint): void {
1659 if(!isWasmInitialized) {
1660 throw new Error("initializeWasm() must be awaited first!");
1662 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
1663 // debug statements here
1665 // struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
1667 export function CResult_PublicKeyNoneZ_get_ok(owner: bigint): number {
1668 if(!isWasmInitialized) {
1669 throw new Error("initializeWasm() must be awaited first!");
1671 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_ok(owner);
1672 return nativeResponseValue;
1674 // void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner);
1676 export function CResult_PublicKeyNoneZ_get_err(owner: bigint): void {
1677 if(!isWasmInitialized) {
1678 throw new Error("initializeWasm() must be awaited first!");
1680 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_get_err(owner);
1681 // debug statements here
1684 export class LDKCOption_BigEndianScalarZ {
1685 protected constructor() {}
1688 export function LDKCOption_BigEndianScalarZ_ty_from_ptr(ptr: bigint): number {
1689 if(!isWasmInitialized) {
1690 throw new Error("initializeWasm() must be awaited first!");
1692 const nativeResponseValue = wasm.TS_LDKCOption_BigEndianScalarZ_ty_from_ptr(ptr);
1693 return nativeResponseValue;
1696 export function LDKCOption_BigEndianScalarZ_Some_get_some(ptr: bigint): bigint {
1697 if(!isWasmInitialized) {
1698 throw new Error("initializeWasm() must be awaited first!");
1700 const nativeResponseValue = wasm.TS_LDKCOption_BigEndianScalarZ_Some_get_some(ptr);
1701 return nativeResponseValue;
1703 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
1705 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: bigint): number {
1706 if(!isWasmInitialized) {
1707 throw new Error("initializeWasm() must be awaited first!");
1709 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
1710 return nativeResponseValue;
1712 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
1714 export function CResult_RecoverableSignatureNoneZ_get_err(owner: bigint): void {
1715 if(!isWasmInitialized) {
1716 throw new Error("initializeWasm() must be awaited first!");
1718 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
1719 // debug statements here
1721 // struct LDKSchnorrSignature CResult_SchnorrSignatureNoneZ_get_ok(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR owner);
1723 export function CResult_SchnorrSignatureNoneZ_get_ok(owner: bigint): number {
1724 if(!isWasmInitialized) {
1725 throw new Error("initializeWasm() must be awaited first!");
1727 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_get_ok(owner);
1728 return nativeResponseValue;
1730 // void CResult_SchnorrSignatureNoneZ_get_err(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR owner);
1732 export function CResult_SchnorrSignatureNoneZ_get_err(owner: bigint): void {
1733 if(!isWasmInitialized) {
1734 throw new Error("initializeWasm() must be awaited first!");
1736 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_get_err(owner);
1737 // debug statements here
1739 // struct LDKECDSASignature CResult_ECDSASignatureNoneZ_get_ok(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR owner);
1741 export function CResult_ECDSASignatureNoneZ_get_ok(owner: bigint): number {
1742 if(!isWasmInitialized) {
1743 throw new Error("initializeWasm() must be awaited first!");
1745 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_get_ok(owner);
1746 return nativeResponseValue;
1748 // void CResult_ECDSASignatureNoneZ_get_err(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR owner);
1750 export function CResult_ECDSASignatureNoneZ_get_err(owner: bigint): void {
1751 if(!isWasmInitialized) {
1752 throw new Error("initializeWasm() must be awaited first!");
1754 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_get_err(owner);
1755 // debug statements here
1757 // struct LDKECDSASignature C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR owner);
1759 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(owner: bigint): number {
1760 if(!isWasmInitialized) {
1761 throw new Error("initializeWasm() must be awaited first!");
1763 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(owner);
1764 return nativeResponseValue;
1766 // struct LDKCVec_ECDSASignatureZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR owner);
1768 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(owner: bigint): number {
1769 if(!isWasmInitialized) {
1770 throw new Error("initializeWasm() must be awaited first!");
1772 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(owner);
1773 return nativeResponseValue;
1775 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR owner);
1777 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(owner: bigint): bigint {
1778 if(!isWasmInitialized) {
1779 throw new Error("initializeWasm() must be awaited first!");
1781 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(owner);
1782 return nativeResponseValue;
1784 // void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR owner);
1786 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(owner: bigint): void {
1787 if(!isWasmInitialized) {
1788 throw new Error("initializeWasm() must be awaited first!");
1790 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(owner);
1791 // debug statements here
1794 export interface LDKChannelSigner {
1795 get_per_commitment_point (idx: bigint): number;
1796 release_commitment_secret (idx: bigint): number;
1797 validate_holder_commitment (holder_tx: bigint, outbound_htlc_preimages: number): bigint;
1798 validate_counterparty_revocation (idx: bigint, secret: number): bigint;
1799 channel_keys_id (): number;
1800 provide_channel_parameters (channel_parameters: bigint): void;
1804 export function LDKChannelSigner_new(impl: LDKChannelSigner, pubkeys: bigint): [bigint, number] {
1805 if(!isWasmInitialized) {
1806 throw new Error("initializeWasm() must be awaited first!");
1808 var new_obj_idx = js_objs.length;
1809 for (var i = 0; i < js_objs.length; i++) {
1810 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1812 js_objs[i] = new WeakRef(impl);
1813 return [wasm.TS_LDKChannelSigner_new(i, pubkeys), i];
1815 // LDKPublicKey ChannelSigner_get_per_commitment_point LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
1817 export function ChannelSigner_get_per_commitment_point(this_arg: bigint, idx: bigint): number {
1818 if(!isWasmInitialized) {
1819 throw new Error("initializeWasm() must be awaited first!");
1821 const nativeResponseValue = wasm.TS_ChannelSigner_get_per_commitment_point(this_arg, idx);
1822 return nativeResponseValue;
1824 // LDKThirtyTwoBytes ChannelSigner_release_commitment_secret LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx
1826 export function ChannelSigner_release_commitment_secret(this_arg: bigint, idx: bigint): number {
1827 if(!isWasmInitialized) {
1828 throw new Error("initializeWasm() must be awaited first!");
1830 const nativeResponseValue = wasm.TS_ChannelSigner_release_commitment_secret(this_arg, idx);
1831 return nativeResponseValue;
1833 // LDKCResult_NoneNoneZ ChannelSigner_validate_holder_commitment LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages
1835 export function ChannelSigner_validate_holder_commitment(this_arg: bigint, holder_tx: bigint, outbound_htlc_preimages: number): bigint {
1836 if(!isWasmInitialized) {
1837 throw new Error("initializeWasm() must be awaited first!");
1839 const nativeResponseValue = wasm.TS_ChannelSigner_validate_holder_commitment(this_arg, holder_tx, outbound_htlc_preimages);
1840 return nativeResponseValue;
1842 // LDKCResult_NoneNoneZ ChannelSigner_validate_counterparty_revocation LDKChannelSigner *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
1844 export function ChannelSigner_validate_counterparty_revocation(this_arg: bigint, idx: bigint, secret: number): bigint {
1845 if(!isWasmInitialized) {
1846 throw new Error("initializeWasm() must be awaited first!");
1848 const nativeResponseValue = wasm.TS_ChannelSigner_validate_counterparty_revocation(this_arg, idx, secret);
1849 return nativeResponseValue;
1851 // LDKThirtyTwoBytes ChannelSigner_channel_keys_id LDKChannelSigner *NONNULL_PTR this_arg
1853 export function ChannelSigner_channel_keys_id(this_arg: bigint): number {
1854 if(!isWasmInitialized) {
1855 throw new Error("initializeWasm() must be awaited first!");
1857 const nativeResponseValue = wasm.TS_ChannelSigner_channel_keys_id(this_arg);
1858 return nativeResponseValue;
1860 // void ChannelSigner_provide_channel_parameters LDKChannelSigner *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
1862 export function ChannelSigner_provide_channel_parameters(this_arg: bigint, channel_parameters: bigint): void {
1863 if(!isWasmInitialized) {
1864 throw new Error("initializeWasm() must be awaited first!");
1866 const nativeResponseValue = wasm.TS_ChannelSigner_provide_channel_parameters(this_arg, channel_parameters);
1867 // debug statements here
1869 // LDKChannelPublicKeys ChannelSigner_get_pubkeys LDKChannelSigner *NONNULL_PTR this_arg
1871 export function ChannelSigner_get_pubkeys(this_arg: bigint): bigint {
1872 if(!isWasmInitialized) {
1873 throw new Error("initializeWasm() must be awaited first!");
1875 const nativeResponseValue = wasm.TS_ChannelSigner_get_pubkeys(this_arg);
1876 return nativeResponseValue;
1879 export interface LDKEcdsaChannelSigner {
1880 sign_counterparty_commitment (commitment_tx: bigint, inbound_htlc_preimages: number, outbound_htlc_preimages: number): bigint;
1881 sign_holder_commitment (commitment_tx: bigint): bigint;
1882 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint;
1883 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint;
1884 sign_holder_htlc_transaction (htlc_tx: number, input: number, htlc_descriptor: bigint): bigint;
1885 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint;
1886 sign_closing_transaction (closing_tx: bigint): bigint;
1887 sign_holder_anchor_input (anchor_tx: number, input: number): bigint;
1888 sign_channel_announcement_with_funding_key (msg: bigint): bigint;
1892 export function LDKEcdsaChannelSigner_new(impl: LDKEcdsaChannelSigner, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
1893 if(!isWasmInitialized) {
1894 throw new Error("initializeWasm() must be awaited first!");
1896 var new_obj_idx = js_objs.length;
1897 for (var i = 0; i < js_objs.length; i++) {
1898 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1900 js_objs[i] = new WeakRef(impl);
1901 return [wasm.TS_LDKEcdsaChannelSigner_new(i, ChannelSigner, pubkeys), i];
1903 // LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner_sign_counterparty_commitment LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ inbound_htlc_preimages, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages
1905 export function EcdsaChannelSigner_sign_counterparty_commitment(this_arg: bigint, commitment_tx: bigint, inbound_htlc_preimages: number, outbound_htlc_preimages: number): bigint {
1906 if(!isWasmInitialized) {
1907 throw new Error("initializeWasm() must be awaited first!");
1909 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_commitment(this_arg, commitment_tx, inbound_htlc_preimages, outbound_htlc_preimages);
1910 return nativeResponseValue;
1912 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_holder_commitment LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
1914 export function EcdsaChannelSigner_sign_holder_commitment(this_arg: bigint, commitment_tx: bigint): bigint {
1915 if(!isWasmInitialized) {
1916 throw new Error("initializeWasm() must be awaited first!");
1918 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_commitment(this_arg, commitment_tx);
1919 return nativeResponseValue;
1921 // 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]
1923 export function EcdsaChannelSigner_sign_justice_revoked_output(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): bigint {
1924 if(!isWasmInitialized) {
1925 throw new Error("initializeWasm() must be awaited first!");
1927 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
1928 return nativeResponseValue;
1930 // 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
1932 export function EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg: bigint, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: bigint): bigint {
1933 if(!isWasmInitialized) {
1934 throw new Error("initializeWasm() must be awaited first!");
1936 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
1937 return nativeResponseValue;
1939 // 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
1941 export function EcdsaChannelSigner_sign_holder_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, htlc_descriptor: bigint): bigint {
1942 if(!isWasmInitialized) {
1943 throw new Error("initializeWasm() must be awaited first!");
1945 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_htlc_transaction(this_arg, htlc_tx, input, htlc_descriptor);
1946 return nativeResponseValue;
1948 // 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
1950 export function EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg: bigint, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: bigint): bigint {
1951 if(!isWasmInitialized) {
1952 throw new Error("initializeWasm() must be awaited first!");
1954 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
1955 return nativeResponseValue;
1957 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_closing_transaction LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
1959 export function EcdsaChannelSigner_sign_closing_transaction(this_arg: bigint, closing_tx: bigint): bigint {
1960 if(!isWasmInitialized) {
1961 throw new Error("initializeWasm() must be awaited first!");
1963 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_closing_transaction(this_arg, closing_tx);
1964 return nativeResponseValue;
1966 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_holder_anchor_input LDKEcdsaChannelSigner *NONNULL_PTR this_arg, struct LDKTransaction anchor_tx, uintptr_t input
1968 export function EcdsaChannelSigner_sign_holder_anchor_input(this_arg: bigint, anchor_tx: number, input: number): bigint {
1969 if(!isWasmInitialized) {
1970 throw new Error("initializeWasm() must be awaited first!");
1972 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_holder_anchor_input(this_arg, anchor_tx, input);
1973 return nativeResponseValue;
1975 // LDKCResult_ECDSASignatureNoneZ EcdsaChannelSigner_sign_channel_announcement_with_funding_key LDKEcdsaChannelSigner *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
1977 export function EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg: bigint, msg: bigint): bigint {
1978 if(!isWasmInitialized) {
1979 throw new Error("initializeWasm() must be awaited first!");
1981 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_sign_channel_announcement_with_funding_key(this_arg, msg);
1982 return nativeResponseValue;
1985 export interface LDKWriteableEcdsaChannelSigner {
1990 export function LDKWriteableEcdsaChannelSigner_new(impl: LDKWriteableEcdsaChannelSigner, EcdsaChannelSigner: number, ChannelSigner: number, pubkeys: bigint): [bigint, number] {
1991 if(!isWasmInitialized) {
1992 throw new Error("initializeWasm() must be awaited first!");
1994 var new_obj_idx = js_objs.length;
1995 for (var i = 0; i < js_objs.length; i++) {
1996 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1998 js_objs[i] = new WeakRef(impl);
1999 return [wasm.TS_LDKWriteableEcdsaChannelSigner_new(i, EcdsaChannelSigner, ChannelSigner, pubkeys), i];
2001 // LDKCVec_u8Z WriteableEcdsaChannelSigner_write LDKWriteableEcdsaChannelSigner *NONNULL_PTR this_arg
2003 export function WriteableEcdsaChannelSigner_write(this_arg: bigint): number {
2004 if(!isWasmInitialized) {
2005 throw new Error("initializeWasm() must be awaited first!");
2007 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_write(this_arg);
2008 return nativeResponseValue;
2010 // struct LDKWriteableEcdsaChannelSigner CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
2012 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner: bigint): bigint {
2013 if(!isWasmInitialized) {
2014 throw new Error("initializeWasm() must be awaited first!");
2016 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner);
2017 return nativeResponseValue;
2019 // struct LDKDecodeError CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner);
2021 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner: bigint): bigint {
2022 if(!isWasmInitialized) {
2023 throw new Error("initializeWasm() must be awaited first!");
2025 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner);
2026 return nativeResponseValue;
2028 // struct LDKCVec_u8Z CResult_CVec_u8ZNoneZ_get_ok(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR owner);
2030 export function CResult_CVec_u8ZNoneZ_get_ok(owner: bigint): number {
2031 if(!isWasmInitialized) {
2032 throw new Error("initializeWasm() must be awaited first!");
2034 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_get_ok(owner);
2035 return nativeResponseValue;
2037 // void CResult_CVec_u8ZNoneZ_get_err(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR owner);
2039 export function CResult_CVec_u8ZNoneZ_get_err(owner: bigint): void {
2040 if(!isWasmInitialized) {
2041 throw new Error("initializeWasm() must be awaited first!");
2043 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_get_err(owner);
2044 // debug statements here
2046 // struct LDKShutdownScript CResult_ShutdownScriptNoneZ_get_ok(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner);
2048 export function CResult_ShutdownScriptNoneZ_get_ok(owner: bigint): bigint {
2049 if(!isWasmInitialized) {
2050 throw new Error("initializeWasm() must be awaited first!");
2052 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_get_ok(owner);
2053 return nativeResponseValue;
2055 // void CResult_ShutdownScriptNoneZ_get_err(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner);
2057 export function CResult_ShutdownScriptNoneZ_get_err(owner: bigint): void {
2058 if(!isWasmInitialized) {
2059 throw new Error("initializeWasm() must be awaited first!");
2061 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_get_err(owner);
2062 // debug statements here
2065 export class LDKCOption_u16Z {
2066 protected constructor() {}
2069 export function LDKCOption_u16Z_ty_from_ptr(ptr: bigint): number {
2070 if(!isWasmInitialized) {
2071 throw new Error("initializeWasm() must be awaited first!");
2073 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
2074 return nativeResponseValue;
2077 export function LDKCOption_u16Z_Some_get_some(ptr: bigint): number {
2078 if(!isWasmInitialized) {
2079 throw new Error("initializeWasm() must be awaited first!");
2081 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
2082 return nativeResponseValue;
2085 export class LDKCOption_boolZ {
2086 protected constructor() {}
2089 export function LDKCOption_boolZ_ty_from_ptr(ptr: bigint): number {
2090 if(!isWasmInitialized) {
2091 throw new Error("initializeWasm() must be awaited first!");
2093 const nativeResponseValue = wasm.TS_LDKCOption_boolZ_ty_from_ptr(ptr);
2094 return nativeResponseValue;
2097 export function LDKCOption_boolZ_Some_get_some(ptr: bigint): boolean {
2098 if(!isWasmInitialized) {
2099 throw new Error("initializeWasm() must be awaited first!");
2101 const nativeResponseValue = wasm.TS_LDKCOption_boolZ_Some_get_some(ptr);
2102 return nativeResponseValue;
2104 // struct LDKWitness CResult_WitnessNoneZ_get_ok(LDKCResult_WitnessNoneZ *NONNULL_PTR owner);
2106 export function CResult_WitnessNoneZ_get_ok(owner: bigint): number {
2107 if(!isWasmInitialized) {
2108 throw new Error("initializeWasm() must be awaited first!");
2110 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_get_ok(owner);
2111 return nativeResponseValue;
2113 // void CResult_WitnessNoneZ_get_err(LDKCResult_WitnessNoneZ *NONNULL_PTR owner);
2115 export function CResult_WitnessNoneZ_get_err(owner: bigint): void {
2116 if(!isWasmInitialized) {
2117 throw new Error("initializeWasm() must be awaited first!");
2119 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_get_err(owner);
2120 // debug statements here
2122 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2124 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: bigint): bigint {
2125 if(!isWasmInitialized) {
2126 throw new Error("initializeWasm() must be awaited first!");
2128 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
2129 return nativeResponseValue;
2131 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2133 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: bigint): bigint {
2134 if(!isWasmInitialized) {
2135 throw new Error("initializeWasm() must be awaited first!");
2137 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
2138 return nativeResponseValue;
2140 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2142 export function CResult_TransactionNoneZ_get_ok(owner: bigint): number {
2143 if(!isWasmInitialized) {
2144 throw new Error("initializeWasm() must be awaited first!");
2146 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
2147 return nativeResponseValue;
2149 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2151 export function CResult_TransactionNoneZ_get_err(owner: bigint): void {
2152 if(!isWasmInitialized) {
2153 throw new Error("initializeWasm() must be awaited first!");
2155 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
2156 // debug statements here
2158 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2160 export function CResult_RouteLightningErrorZ_get_ok(owner: bigint): bigint {
2161 if(!isWasmInitialized) {
2162 throw new Error("initializeWasm() must be awaited first!");
2164 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
2165 return nativeResponseValue;
2167 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2169 export function CResult_RouteLightningErrorZ_get_err(owner: bigint): bigint {
2170 if(!isWasmInitialized) {
2171 throw new Error("initializeWasm() must be awaited first!");
2173 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
2174 return nativeResponseValue;
2176 // struct LDKBlindedPayInfo C2Tuple_BlindedPayInfoBlindedPathZ_get_a(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
2178 export function C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner: bigint): bigint {
2179 if(!isWasmInitialized) {
2180 throw new Error("initializeWasm() must be awaited first!");
2182 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner);
2183 return nativeResponseValue;
2185 // struct LDKBlindedPath C2Tuple_BlindedPayInfoBlindedPathZ_get_b(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner);
2187 export function C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner: bigint): bigint {
2188 if(!isWasmInitialized) {
2189 throw new Error("initializeWasm() must be awaited first!");
2191 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner);
2192 return nativeResponseValue;
2194 // struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_ok(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR owner);
2196 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_ok(owner: bigint): number {
2197 if(!isWasmInitialized) {
2198 throw new Error("initializeWasm() must be awaited first!");
2200 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_ok(owner);
2201 return nativeResponseValue;
2203 // void CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_err(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR owner);
2205 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_err(owner: bigint): void {
2206 if(!isWasmInitialized) {
2207 throw new Error("initializeWasm() must be awaited first!");
2209 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_get_err(owner);
2210 // debug statements here
2212 // struct LDKOnionMessagePath CResult_OnionMessagePathNoneZ_get_ok(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner);
2214 export function CResult_OnionMessagePathNoneZ_get_ok(owner: bigint): bigint {
2215 if(!isWasmInitialized) {
2216 throw new Error("initializeWasm() must be awaited first!");
2218 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_get_ok(owner);
2219 return nativeResponseValue;
2221 // void CResult_OnionMessagePathNoneZ_get_err(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner);
2223 export function CResult_OnionMessagePathNoneZ_get_err(owner: bigint): void {
2224 if(!isWasmInitialized) {
2225 throw new Error("initializeWasm() must be awaited first!");
2227 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_get_err(owner);
2228 // debug statements here
2230 // struct LDKCVec_BlindedPathZ CResult_CVec_BlindedPathZNoneZ_get_ok(LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR owner);
2232 export function CResult_CVec_BlindedPathZNoneZ_get_ok(owner: bigint): number {
2233 if(!isWasmInitialized) {
2234 throw new Error("initializeWasm() must be awaited first!");
2236 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_get_ok(owner);
2237 return nativeResponseValue;
2239 // void CResult_CVec_BlindedPathZNoneZ_get_err(LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR owner);
2241 export function CResult_CVec_BlindedPathZNoneZ_get_err(owner: bigint): void {
2242 if(!isWasmInitialized) {
2243 throw new Error("initializeWasm() must be awaited first!");
2245 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_get_err(owner);
2246 // debug statements here
2248 // struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
2250 export function CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner: bigint): bigint {
2251 if(!isWasmInitialized) {
2252 throw new Error("initializeWasm() must be awaited first!");
2254 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner);
2255 return nativeResponseValue;
2257 // struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner);
2259 export function CResult_InFlightHtlcsDecodeErrorZ_get_err(owner: bigint): bigint {
2260 if(!isWasmInitialized) {
2261 throw new Error("initializeWasm() must be awaited first!");
2263 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(owner);
2264 return nativeResponseValue;
2266 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
2268 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: bigint): bigint {
2269 if(!isWasmInitialized) {
2270 throw new Error("initializeWasm() must be awaited first!");
2272 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
2273 return nativeResponseValue;
2275 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
2277 export function CResult_RouteHopDecodeErrorZ_get_err(owner: bigint): bigint {
2278 if(!isWasmInitialized) {
2279 throw new Error("initializeWasm() must be awaited first!");
2281 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
2282 return nativeResponseValue;
2284 // struct LDKBlindedTail CResult_BlindedTailDecodeErrorZ_get_ok(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
2286 export function CResult_BlindedTailDecodeErrorZ_get_ok(owner: bigint): bigint {
2287 if(!isWasmInitialized) {
2288 throw new Error("initializeWasm() must be awaited first!");
2290 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_ok(owner);
2291 return nativeResponseValue;
2293 // struct LDKDecodeError CResult_BlindedTailDecodeErrorZ_get_err(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner);
2295 export function CResult_BlindedTailDecodeErrorZ_get_err(owner: bigint): bigint {
2296 if(!isWasmInitialized) {
2297 throw new Error("initializeWasm() must be awaited first!");
2299 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_get_err(owner);
2300 return nativeResponseValue;
2302 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
2304 export function CResult_RouteDecodeErrorZ_get_ok(owner: bigint): bigint {
2305 if(!isWasmInitialized) {
2306 throw new Error("initializeWasm() must be awaited first!");
2308 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
2309 return nativeResponseValue;
2311 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
2313 export function CResult_RouteDecodeErrorZ_get_err(owner: bigint): bigint {
2314 if(!isWasmInitialized) {
2315 throw new Error("initializeWasm() must be awaited first!");
2317 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
2318 return nativeResponseValue;
2320 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
2322 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
2323 if(!isWasmInitialized) {
2324 throw new Error("initializeWasm() must be awaited first!");
2326 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
2327 return nativeResponseValue;
2329 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
2331 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: bigint): bigint {
2332 if(!isWasmInitialized) {
2333 throw new Error("initializeWasm() must be awaited first!");
2335 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
2336 return nativeResponseValue;
2338 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
2340 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
2341 if(!isWasmInitialized) {
2342 throw new Error("initializeWasm() must be awaited first!");
2344 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
2345 return nativeResponseValue;
2347 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
2349 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: bigint): bigint {
2350 if(!isWasmInitialized) {
2351 throw new Error("initializeWasm() must be awaited first!");
2353 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
2354 return nativeResponseValue;
2356 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2358 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: bigint): bigint {
2359 if(!isWasmInitialized) {
2360 throw new Error("initializeWasm() must be awaited first!");
2362 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
2363 return nativeResponseValue;
2365 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2367 export function CResult_RouteHintDecodeErrorZ_get_err(owner: bigint): bigint {
2368 if(!isWasmInitialized) {
2369 throw new Error("initializeWasm() must be awaited first!");
2371 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
2372 return nativeResponseValue;
2374 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2376 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: bigint): bigint {
2377 if(!isWasmInitialized) {
2378 throw new Error("initializeWasm() must be awaited first!");
2380 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
2381 return nativeResponseValue;
2383 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2385 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: bigint): bigint {
2386 if(!isWasmInitialized) {
2387 throw new Error("initializeWasm() must be awaited first!");
2389 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
2390 return nativeResponseValue;
2392 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2394 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2395 if(!isWasmInitialized) {
2396 throw new Error("initializeWasm() must be awaited first!");
2398 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2399 return nativeResponseValue;
2401 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2403 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2404 if(!isWasmInitialized) {
2405 throw new Error("initializeWasm() must be awaited first!");
2407 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2408 return nativeResponseValue;
2410 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2412 export function C2Tuple_u64u64Z_get_a(owner: bigint): bigint {
2413 if(!isWasmInitialized) {
2414 throw new Error("initializeWasm() must be awaited first!");
2416 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2417 return nativeResponseValue;
2419 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2421 export function C2Tuple_u64u64Z_get_b(owner: bigint): bigint {
2422 if(!isWasmInitialized) {
2423 throw new Error("initializeWasm() must be awaited first!");
2425 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2426 return nativeResponseValue;
2429 export class LDKCOption_C2Tuple_u64u64ZZ {
2430 protected constructor() {}
2433 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: bigint): number {
2434 if(!isWasmInitialized) {
2435 throw new Error("initializeWasm() must be awaited first!");
2437 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2438 return nativeResponseValue;
2441 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: bigint): bigint {
2442 if(!isWasmInitialized) {
2443 throw new Error("initializeWasm() must be awaited first!");
2445 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2446 return nativeResponseValue;
2448 // struct LDKThirtyTwoU16s C2Tuple_Z_get_a(LDKC2Tuple_Z *NONNULL_PTR owner);
2450 export function C2Tuple_Z_get_a(owner: bigint): number {
2451 if(!isWasmInitialized) {
2452 throw new Error("initializeWasm() must be awaited first!");
2454 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_a(owner);
2455 return nativeResponseValue;
2457 // struct LDKThirtyTwoU16s C2Tuple_Z_get_b(LDKC2Tuple_Z *NONNULL_PTR owner);
2459 export function C2Tuple_Z_get_b(owner: bigint): number {
2460 if(!isWasmInitialized) {
2461 throw new Error("initializeWasm() must be awaited first!");
2463 const nativeResponseValue = wasm.TS_C2Tuple_Z_get_b(owner);
2464 return nativeResponseValue;
2466 // struct LDKThirtyTwoU16s C2Tuple__u1632_u1632Z_get_a(LDKC2Tuple__u1632_u1632Z *NONNULL_PTR owner);
2468 export function C2Tuple__u1632_u1632Z_get_a(owner: bigint): number {
2469 if(!isWasmInitialized) {
2470 throw new Error("initializeWasm() must be awaited first!");
2472 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_get_a(owner);
2473 return nativeResponseValue;
2475 // struct LDKThirtyTwoU16s C2Tuple__u1632_u1632Z_get_b(LDKC2Tuple__u1632_u1632Z *NONNULL_PTR owner);
2477 export function C2Tuple__u1632_u1632Z_get_b(owner: bigint): number {
2478 if(!isWasmInitialized) {
2479 throw new Error("initializeWasm() must be awaited first!");
2481 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_get_b(owner);
2482 return nativeResponseValue;
2485 export class LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ {
2486 protected constructor() {}
2489 export function LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_ty_from_ptr(ptr: bigint): number {
2490 if(!isWasmInitialized) {
2491 throw new Error("initializeWasm() must be awaited first!");
2493 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_ty_from_ptr(ptr);
2494 return nativeResponseValue;
2497 export function LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some_get_some(ptr: bigint): bigint {
2498 if(!isWasmInitialized) {
2499 throw new Error("initializeWasm() must be awaited first!");
2501 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some_get_some(ptr);
2502 return nativeResponseValue;
2505 export class LDKCOption_f64Z {
2506 protected constructor() {}
2509 export function LDKCOption_f64Z_ty_from_ptr(ptr: bigint): number {
2510 if(!isWasmInitialized) {
2511 throw new Error("initializeWasm() must be awaited first!");
2513 const nativeResponseValue = wasm.TS_LDKCOption_f64Z_ty_from_ptr(ptr);
2514 return nativeResponseValue;
2517 export function LDKCOption_f64Z_Some_get_some(ptr: bigint): number {
2518 if(!isWasmInitialized) {
2519 throw new Error("initializeWasm() must be awaited first!");
2521 const nativeResponseValue = wasm.TS_LDKCOption_f64Z_Some_get_some(ptr);
2522 return nativeResponseValue;
2525 export interface LDKLogger {
2526 log (record: bigint): void;
2530 export function LDKLogger_new(impl: LDKLogger): [bigint, number] {
2531 if(!isWasmInitialized) {
2532 throw new Error("initializeWasm() must be awaited first!");
2534 var new_obj_idx = js_objs.length;
2535 for (var i = 0; i < js_objs.length; i++) {
2536 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2538 js_objs[i] = new WeakRef(impl);
2539 return [wasm.TS_LDKLogger_new(i), i];
2541 // struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2543 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: bigint): bigint {
2544 if(!isWasmInitialized) {
2545 throw new Error("initializeWasm() must be awaited first!");
2547 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2548 return nativeResponseValue;
2550 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2552 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: bigint): bigint {
2553 if(!isWasmInitialized) {
2554 throw new Error("initializeWasm() must be awaited first!");
2556 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2557 return nativeResponseValue;
2559 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2561 export function C2Tuple_usizeTransactionZ_get_a(owner: bigint): number {
2562 if(!isWasmInitialized) {
2563 throw new Error("initializeWasm() must be awaited first!");
2565 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2566 return nativeResponseValue;
2568 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2570 export function C2Tuple_usizeTransactionZ_get_b(owner: bigint): number {
2571 if(!isWasmInitialized) {
2572 throw new Error("initializeWasm() must be awaited first!");
2574 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2575 return nativeResponseValue;
2577 // struct LDKThirtyTwoBytes C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_a(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ *NONNULL_PTR owner);
2579 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_a(owner: bigint): number {
2580 if(!isWasmInitialized) {
2581 throw new Error("initializeWasm() must be awaited first!");
2583 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_a(owner);
2584 return nativeResponseValue;
2586 // uint32_t C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_b(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ *NONNULL_PTR owner);
2588 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_b(owner: bigint): number {
2589 if(!isWasmInitialized) {
2590 throw new Error("initializeWasm() must be awaited first!");
2592 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_b(owner);
2593 return nativeResponseValue;
2595 // struct LDKCOption_ThirtyTwoBytesZ C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_c(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ *NONNULL_PTR owner);
2597 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_c(owner: bigint): bigint {
2598 if(!isWasmInitialized) {
2599 throw new Error("initializeWasm() must be awaited first!");
2601 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_get_c(owner);
2602 return nativeResponseValue;
2604 // enum LDKChannelMonitorUpdateStatus CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR owner);
2606 export function CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(owner: bigint): ChannelMonitorUpdateStatus {
2607 if(!isWasmInitialized) {
2608 throw new Error("initializeWasm() must be awaited first!");
2610 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(owner);
2611 return nativeResponseValue;
2613 // void CResult_ChannelMonitorUpdateStatusNoneZ_get_err(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR owner);
2615 export function CResult_ChannelMonitorUpdateStatusNoneZ_get_err(owner: bigint): void {
2616 if(!isWasmInitialized) {
2617 throw new Error("initializeWasm() must be awaited first!");
2619 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_err(owner);
2620 // debug statements here
2623 export class LDKMonitorEvent {
2624 protected constructor() {}
2627 export function LDKMonitorEvent_ty_from_ptr(ptr: bigint): number {
2628 if(!isWasmInitialized) {
2629 throw new Error("initializeWasm() must be awaited first!");
2631 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2632 return nativeResponseValue;
2635 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: bigint): bigint {
2636 if(!isWasmInitialized) {
2637 throw new Error("initializeWasm() must be awaited first!");
2639 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2640 return nativeResponseValue;
2643 export function LDKMonitorEvent_HolderForceClosed_get_holder_force_closed(ptr: bigint): bigint {
2644 if(!isWasmInitialized) {
2645 throw new Error("initializeWasm() must be awaited first!");
2647 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HolderForceClosed_get_holder_force_closed(ptr);
2648 return nativeResponseValue;
2651 export function LDKMonitorEvent_Completed_get_funding_txo(ptr: bigint): bigint {
2652 if(!isWasmInitialized) {
2653 throw new Error("initializeWasm() must be awaited first!");
2655 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_funding_txo(ptr);
2656 return nativeResponseValue;
2659 export function LDKMonitorEvent_Completed_get_monitor_update_id(ptr: bigint): bigint {
2660 if(!isWasmInitialized) {
2661 throw new Error("initializeWasm() must be awaited first!");
2663 const nativeResponseValue = wasm.TS_LDKMonitorEvent_Completed_get_monitor_update_id(ptr);
2664 return nativeResponseValue;
2666 // struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2668 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: bigint): bigint {
2669 if(!isWasmInitialized) {
2670 throw new Error("initializeWasm() must be awaited first!");
2672 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
2673 return nativeResponseValue;
2675 // struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2677 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: bigint): number {
2678 if(!isWasmInitialized) {
2679 throw new Error("initializeWasm() must be awaited first!");
2681 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
2682 return nativeResponseValue;
2684 // struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2686 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: bigint): number {
2687 if(!isWasmInitialized) {
2688 throw new Error("initializeWasm() must be awaited first!");
2690 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
2691 return nativeResponseValue;
2693 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2695 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2696 if(!isWasmInitialized) {
2697 throw new Error("initializeWasm() must be awaited first!");
2699 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2700 return nativeResponseValue;
2702 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2704 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2705 if(!isWasmInitialized) {
2706 throw new Error("initializeWasm() must be awaited first!");
2708 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2709 return nativeResponseValue;
2711 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2713 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2714 if(!isWasmInitialized) {
2715 throw new Error("initializeWasm() must be awaited first!");
2717 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2718 return nativeResponseValue;
2720 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2722 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2723 if(!isWasmInitialized) {
2724 throw new Error("initializeWasm() must be awaited first!");
2726 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2727 return nativeResponseValue;
2729 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2731 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2732 if(!isWasmInitialized) {
2733 throw new Error("initializeWasm() must be awaited first!");
2735 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2736 return nativeResponseValue;
2738 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2740 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2741 if(!isWasmInitialized) {
2742 throw new Error("initializeWasm() must be awaited first!");
2744 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2745 return nativeResponseValue;
2747 // struct LDKBolt11InvoiceFeatures CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2749 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2750 if(!isWasmInitialized) {
2751 throw new Error("initializeWasm() must be awaited first!");
2753 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2754 return nativeResponseValue;
2756 // struct LDKDecodeError CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2758 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2759 if(!isWasmInitialized) {
2760 throw new Error("initializeWasm() must be awaited first!");
2762 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(owner);
2763 return nativeResponseValue;
2765 // struct LDKBolt12InvoiceFeatures CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2767 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2768 if(!isWasmInitialized) {
2769 throw new Error("initializeWasm() must be awaited first!");
2771 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2772 return nativeResponseValue;
2774 // struct LDKDecodeError CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2776 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2777 if(!isWasmInitialized) {
2778 throw new Error("initializeWasm() must be awaited first!");
2780 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(owner);
2781 return nativeResponseValue;
2783 // struct LDKBlindedHopFeatures CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
2785 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2786 if(!isWasmInitialized) {
2787 throw new Error("initializeWasm() must be awaited first!");
2789 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner);
2790 return nativeResponseValue;
2792 // struct LDKDecodeError CResult_BlindedHopFeaturesDecodeErrorZ_get_err(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner);
2794 export function CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2795 if(!isWasmInitialized) {
2796 throw new Error("initializeWasm() must be awaited first!");
2798 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner);
2799 return nativeResponseValue;
2801 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2803 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
2804 if(!isWasmInitialized) {
2805 throw new Error("initializeWasm() must be awaited first!");
2807 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2808 return nativeResponseValue;
2810 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2812 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: bigint): bigint {
2813 if(!isWasmInitialized) {
2814 throw new Error("initializeWasm() must be awaited first!");
2816 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2817 return nativeResponseValue;
2819 // struct LDKOffer CResult_OfferBolt12ParseErrorZ_get_ok(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner);
2821 export function CResult_OfferBolt12ParseErrorZ_get_ok(owner: bigint): bigint {
2822 if(!isWasmInitialized) {
2823 throw new Error("initializeWasm() must be awaited first!");
2825 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_get_ok(owner);
2826 return nativeResponseValue;
2828 // struct LDKBolt12ParseError CResult_OfferBolt12ParseErrorZ_get_err(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner);
2830 export function CResult_OfferBolt12ParseErrorZ_get_err(owner: bigint): bigint {
2831 if(!isWasmInitialized) {
2832 throw new Error("initializeWasm() must be awaited first!");
2834 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_get_err(owner);
2835 return nativeResponseValue;
2837 // struct LDKPublicKey CResult_PublicKeySecp256k1ErrorZ_get_ok(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR owner);
2839 export function CResult_PublicKeySecp256k1ErrorZ_get_ok(owner: bigint): number {
2840 if(!isWasmInitialized) {
2841 throw new Error("initializeWasm() must be awaited first!");
2843 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_get_ok(owner);
2844 return nativeResponseValue;
2846 // enum LDKSecp256k1Error CResult_PublicKeySecp256k1ErrorZ_get_err(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR owner);
2848 export function CResult_PublicKeySecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
2849 if(!isWasmInitialized) {
2850 throw new Error("initializeWasm() must be awaited first!");
2852 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_get_err(owner);
2853 return nativeResponseValue;
2855 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2857 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: bigint): bigint {
2858 if(!isWasmInitialized) {
2859 throw new Error("initializeWasm() must be awaited first!");
2861 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2862 return nativeResponseValue;
2864 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2866 export function CResult_NodeIdDecodeErrorZ_get_err(owner: bigint): bigint {
2867 if(!isWasmInitialized) {
2868 throw new Error("initializeWasm() must be awaited first!");
2870 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2871 return nativeResponseValue;
2874 export class LDKNetworkUpdate {
2875 protected constructor() {}
2878 export function LDKNetworkUpdate_ty_from_ptr(ptr: bigint): number {
2879 if(!isWasmInitialized) {
2880 throw new Error("initializeWasm() must be awaited first!");
2882 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
2883 return nativeResponseValue;
2886 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: bigint): bigint {
2887 if(!isWasmInitialized) {
2888 throw new Error("initializeWasm() must be awaited first!");
2890 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
2891 return nativeResponseValue;
2894 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: bigint): bigint {
2895 if(!isWasmInitialized) {
2896 throw new Error("initializeWasm() must be awaited first!");
2898 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
2899 return nativeResponseValue;
2902 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: bigint): boolean {
2903 if(!isWasmInitialized) {
2904 throw new Error("initializeWasm() must be awaited first!");
2906 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
2907 return nativeResponseValue;
2910 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: bigint): number {
2911 if(!isWasmInitialized) {
2912 throw new Error("initializeWasm() must be awaited first!");
2914 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
2915 return nativeResponseValue;
2918 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: bigint): boolean {
2919 if(!isWasmInitialized) {
2920 throw new Error("initializeWasm() must be awaited first!");
2922 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
2923 return nativeResponseValue;
2926 export class LDKCOption_NetworkUpdateZ {
2927 protected constructor() {}
2930 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: bigint): number {
2931 if(!isWasmInitialized) {
2932 throw new Error("initializeWasm() must be awaited first!");
2934 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
2935 return nativeResponseValue;
2938 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: bigint): bigint {
2939 if(!isWasmInitialized) {
2940 throw new Error("initializeWasm() must be awaited first!");
2942 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
2943 return nativeResponseValue;
2945 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2947 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: bigint): bigint {
2948 if(!isWasmInitialized) {
2949 throw new Error("initializeWasm() must be awaited first!");
2951 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2952 return nativeResponseValue;
2954 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2956 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: bigint): bigint {
2957 if(!isWasmInitialized) {
2958 throw new Error("initializeWasm() must be awaited first!");
2960 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2961 return nativeResponseValue;
2963 // struct LDKTxOut CResult_TxOutUtxoLookupErrorZ_get_ok(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
2965 export function CResult_TxOutUtxoLookupErrorZ_get_ok(owner: bigint): bigint {
2966 if(!isWasmInitialized) {
2967 throw new Error("initializeWasm() must be awaited first!");
2969 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_ok(owner);
2970 return nativeResponseValue;
2972 // enum LDKUtxoLookupError CResult_TxOutUtxoLookupErrorZ_get_err(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner);
2974 export function CResult_TxOutUtxoLookupErrorZ_get_err(owner: bigint): UtxoLookupError {
2975 if(!isWasmInitialized) {
2976 throw new Error("initializeWasm() must be awaited first!");
2978 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_get_err(owner);
2979 return nativeResponseValue;
2982 export class LDKUtxoResult {
2983 protected constructor() {}
2986 export function LDKUtxoResult_ty_from_ptr(ptr: bigint): number {
2987 if(!isWasmInitialized) {
2988 throw new Error("initializeWasm() must be awaited first!");
2990 const nativeResponseValue = wasm.TS_LDKUtxoResult_ty_from_ptr(ptr);
2991 return nativeResponseValue;
2994 export function LDKUtxoResult_Sync_get_sync(ptr: bigint): bigint {
2995 if(!isWasmInitialized) {
2996 throw new Error("initializeWasm() must be awaited first!");
2998 const nativeResponseValue = wasm.TS_LDKUtxoResult_Sync_get_sync(ptr);
2999 return nativeResponseValue;
3002 export function LDKUtxoResult_Async_get_async(ptr: bigint): bigint {
3003 if(!isWasmInitialized) {
3004 throw new Error("initializeWasm() must be awaited first!");
3006 const nativeResponseValue = wasm.TS_LDKUtxoResult_Async_get_async(ptr);
3007 return nativeResponseValue;
3010 export interface LDKUtxoLookup {
3011 get_utxo (chain_hash: number, short_channel_id: bigint): bigint;
3015 export function LDKUtxoLookup_new(impl: LDKUtxoLookup): [bigint, number] {
3016 if(!isWasmInitialized) {
3017 throw new Error("initializeWasm() must be awaited first!");
3019 var new_obj_idx = js_objs.length;
3020 for (var i = 0; i < js_objs.length; i++) {
3021 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3023 js_objs[i] = new WeakRef(impl);
3024 return [wasm.TS_LDKUtxoLookup_new(i), i];
3026 // LDKUtxoResult UtxoLookup_get_utxo LDKUtxoLookup *NONNULL_PTR this_arg, const uint8_t (*chain_hash)[32], uint64_t short_channel_id
3028 export function UtxoLookup_get_utxo(this_arg: bigint, chain_hash: number, short_channel_id: bigint): bigint {
3029 if(!isWasmInitialized) {
3030 throw new Error("initializeWasm() must be awaited first!");
3032 const nativeResponseValue = wasm.TS_UtxoLookup_get_utxo(this_arg, chain_hash, short_channel_id);
3033 return nativeResponseValue;
3036 export class LDKCOption_UtxoLookupZ {
3037 protected constructor() {}
3040 export function LDKCOption_UtxoLookupZ_ty_from_ptr(ptr: bigint): number {
3041 if(!isWasmInitialized) {
3042 throw new Error("initializeWasm() must be awaited first!");
3044 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_ty_from_ptr(ptr);
3045 return nativeResponseValue;
3048 export function LDKCOption_UtxoLookupZ_Some_get_some(ptr: bigint): bigint {
3049 if(!isWasmInitialized) {
3050 throw new Error("initializeWasm() must be awaited first!");
3052 const nativeResponseValue = wasm.TS_LDKCOption_UtxoLookupZ_Some_get_some(ptr);
3053 return nativeResponseValue;
3055 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
3057 export function CResult_NoneLightningErrorZ_get_ok(owner: bigint): void {
3058 if(!isWasmInitialized) {
3059 throw new Error("initializeWasm() must be awaited first!");
3061 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
3062 // debug statements here
3064 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
3066 export function CResult_NoneLightningErrorZ_get_err(owner: bigint): bigint {
3067 if(!isWasmInitialized) {
3068 throw new Error("initializeWasm() must be awaited first!");
3070 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
3071 return nativeResponseValue;
3073 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
3075 export function CResult_boolLightningErrorZ_get_ok(owner: bigint): boolean {
3076 if(!isWasmInitialized) {
3077 throw new Error("initializeWasm() must be awaited first!");
3079 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
3080 return nativeResponseValue;
3082 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
3084 export function CResult_boolLightningErrorZ_get_err(owner: bigint): bigint {
3085 if(!isWasmInitialized) {
3086 throw new Error("initializeWasm() must be awaited first!");
3088 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
3089 return nativeResponseValue;
3091 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3093 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: bigint): bigint {
3094 if(!isWasmInitialized) {
3095 throw new Error("initializeWasm() must be awaited first!");
3097 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
3098 return nativeResponseValue;
3100 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3102 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: bigint): bigint {
3103 if(!isWasmInitialized) {
3104 throw new Error("initializeWasm() must be awaited first!");
3106 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
3107 return nativeResponseValue;
3109 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
3111 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: bigint): bigint {
3112 if(!isWasmInitialized) {
3113 throw new Error("initializeWasm() must be awaited first!");
3115 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
3116 return nativeResponseValue;
3119 export class LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
3120 protected constructor() {}
3123 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr: bigint): number {
3124 if(!isWasmInitialized) {
3125 throw new Error("initializeWasm() must be awaited first!");
3127 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(ptr);
3128 return nativeResponseValue;
3131 export function LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr: bigint): bigint {
3132 if(!isWasmInitialized) {
3133 throw new Error("initializeWasm() must be awaited first!");
3135 const nativeResponseValue = wasm.TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(ptr);
3136 return nativeResponseValue;
3139 export class LDKErrorAction {
3140 protected constructor() {}
3143 export function LDKErrorAction_ty_from_ptr(ptr: bigint): number {
3144 if(!isWasmInitialized) {
3145 throw new Error("initializeWasm() must be awaited first!");
3147 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
3148 return nativeResponseValue;
3151 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: bigint): bigint {
3152 if(!isWasmInitialized) {
3153 throw new Error("initializeWasm() must be awaited first!");
3155 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
3156 return nativeResponseValue;
3159 export function LDKErrorAction_DisconnectPeerWithWarning_get_msg(ptr: bigint): bigint {
3160 if(!isWasmInitialized) {
3161 throw new Error("initializeWasm() must be awaited first!");
3163 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeerWithWarning_get_msg(ptr);
3164 return nativeResponseValue;
3167 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: bigint): Level {
3168 if(!isWasmInitialized) {
3169 throw new Error("initializeWasm() must be awaited first!");
3171 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
3172 return nativeResponseValue;
3175 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: bigint): bigint {
3176 if(!isWasmInitialized) {
3177 throw new Error("initializeWasm() must be awaited first!");
3179 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
3180 return nativeResponseValue;
3183 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: bigint): bigint {
3184 if(!isWasmInitialized) {
3185 throw new Error("initializeWasm() must be awaited first!");
3187 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
3188 return nativeResponseValue;
3191 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: bigint): Level {
3192 if(!isWasmInitialized) {
3193 throw new Error("initializeWasm() must be awaited first!");
3195 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
3196 return nativeResponseValue;
3199 export class LDKMessageSendEvent {
3200 protected constructor() {}
3203 export function LDKMessageSendEvent_ty_from_ptr(ptr: bigint): number {
3204 if(!isWasmInitialized) {
3205 throw new Error("initializeWasm() must be awaited first!");
3207 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
3208 return nativeResponseValue;
3211 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: bigint): number {
3212 if(!isWasmInitialized) {
3213 throw new Error("initializeWasm() must be awaited first!");
3215 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
3216 return nativeResponseValue;
3219 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: bigint): bigint {
3220 if(!isWasmInitialized) {
3221 throw new Error("initializeWasm() must be awaited first!");
3223 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
3224 return nativeResponseValue;
3227 export function LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(ptr: bigint): number {
3228 if(!isWasmInitialized) {
3229 throw new Error("initializeWasm() must be awaited first!");
3231 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(ptr);
3232 return nativeResponseValue;
3235 export function LDKMessageSendEvent_SendAcceptChannelV2_get_msg(ptr: bigint): bigint {
3236 if(!isWasmInitialized) {
3237 throw new Error("initializeWasm() must be awaited first!");
3239 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannelV2_get_msg(ptr);
3240 return nativeResponseValue;
3243 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: bigint): number {
3244 if(!isWasmInitialized) {
3245 throw new Error("initializeWasm() must be awaited first!");
3247 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
3248 return nativeResponseValue;
3251 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: bigint): bigint {
3252 if(!isWasmInitialized) {
3253 throw new Error("initializeWasm() must be awaited first!");
3255 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
3256 return nativeResponseValue;
3259 export function LDKMessageSendEvent_SendOpenChannelV2_get_node_id(ptr: bigint): number {
3260 if(!isWasmInitialized) {
3261 throw new Error("initializeWasm() must be awaited first!");
3263 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannelV2_get_node_id(ptr);
3264 return nativeResponseValue;
3267 export function LDKMessageSendEvent_SendOpenChannelV2_get_msg(ptr: bigint): bigint {
3268 if(!isWasmInitialized) {
3269 throw new Error("initializeWasm() must be awaited first!");
3271 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannelV2_get_msg(ptr);
3272 return nativeResponseValue;
3275 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: bigint): number {
3276 if(!isWasmInitialized) {
3277 throw new Error("initializeWasm() must be awaited first!");
3279 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
3280 return nativeResponseValue;
3283 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: bigint): bigint {
3284 if(!isWasmInitialized) {
3285 throw new Error("initializeWasm() must be awaited first!");
3287 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
3288 return nativeResponseValue;
3291 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: bigint): number {
3292 if(!isWasmInitialized) {
3293 throw new Error("initializeWasm() must be awaited first!");
3295 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
3296 return nativeResponseValue;
3299 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: bigint): bigint {
3300 if(!isWasmInitialized) {
3301 throw new Error("initializeWasm() must be awaited first!");
3303 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
3304 return nativeResponseValue;
3307 export function LDKMessageSendEvent_SendStfu_get_node_id(ptr: bigint): number {
3308 if(!isWasmInitialized) {
3309 throw new Error("initializeWasm() must be awaited first!");
3311 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendStfu_get_node_id(ptr);
3312 return nativeResponseValue;
3315 export function LDKMessageSendEvent_SendStfu_get_msg(ptr: bigint): bigint {
3316 if(!isWasmInitialized) {
3317 throw new Error("initializeWasm() must be awaited first!");
3319 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendStfu_get_msg(ptr);
3320 return nativeResponseValue;
3323 export function LDKMessageSendEvent_SendSplice_get_node_id(ptr: bigint): number {
3324 if(!isWasmInitialized) {
3325 throw new Error("initializeWasm() must be awaited first!");
3327 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSplice_get_node_id(ptr);
3328 return nativeResponseValue;
3331 export function LDKMessageSendEvent_SendSplice_get_msg(ptr: bigint): bigint {
3332 if(!isWasmInitialized) {
3333 throw new Error("initializeWasm() must be awaited first!");
3335 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSplice_get_msg(ptr);
3336 return nativeResponseValue;
3339 export function LDKMessageSendEvent_SendSpliceAck_get_node_id(ptr: bigint): number {
3340 if(!isWasmInitialized) {
3341 throw new Error("initializeWasm() must be awaited first!");
3343 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSpliceAck_get_node_id(ptr);
3344 return nativeResponseValue;
3347 export function LDKMessageSendEvent_SendSpliceAck_get_msg(ptr: bigint): bigint {
3348 if(!isWasmInitialized) {
3349 throw new Error("initializeWasm() must be awaited first!");
3351 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSpliceAck_get_msg(ptr);
3352 return nativeResponseValue;
3355 export function LDKMessageSendEvent_SendSpliceLocked_get_node_id(ptr: bigint): number {
3356 if(!isWasmInitialized) {
3357 throw new Error("initializeWasm() must be awaited first!");
3359 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSpliceLocked_get_node_id(ptr);
3360 return nativeResponseValue;
3363 export function LDKMessageSendEvent_SendSpliceLocked_get_msg(ptr: bigint): bigint {
3364 if(!isWasmInitialized) {
3365 throw new Error("initializeWasm() must be awaited first!");
3367 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendSpliceLocked_get_msg(ptr);
3368 return nativeResponseValue;
3371 export function LDKMessageSendEvent_SendTxAddInput_get_node_id(ptr: bigint): number {
3372 if(!isWasmInitialized) {
3373 throw new Error("initializeWasm() must be awaited first!");
3375 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddInput_get_node_id(ptr);
3376 return nativeResponseValue;
3379 export function LDKMessageSendEvent_SendTxAddInput_get_msg(ptr: bigint): bigint {
3380 if(!isWasmInitialized) {
3381 throw new Error("initializeWasm() must be awaited first!");
3383 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddInput_get_msg(ptr);
3384 return nativeResponseValue;
3387 export function LDKMessageSendEvent_SendTxAddOutput_get_node_id(ptr: bigint): number {
3388 if(!isWasmInitialized) {
3389 throw new Error("initializeWasm() must be awaited first!");
3391 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddOutput_get_node_id(ptr);
3392 return nativeResponseValue;
3395 export function LDKMessageSendEvent_SendTxAddOutput_get_msg(ptr: bigint): bigint {
3396 if(!isWasmInitialized) {
3397 throw new Error("initializeWasm() must be awaited first!");
3399 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAddOutput_get_msg(ptr);
3400 return nativeResponseValue;
3403 export function LDKMessageSendEvent_SendTxRemoveInput_get_node_id(ptr: bigint): number {
3404 if(!isWasmInitialized) {
3405 throw new Error("initializeWasm() must be awaited first!");
3407 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveInput_get_node_id(ptr);
3408 return nativeResponseValue;
3411 export function LDKMessageSendEvent_SendTxRemoveInput_get_msg(ptr: bigint): bigint {
3412 if(!isWasmInitialized) {
3413 throw new Error("initializeWasm() must be awaited first!");
3415 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveInput_get_msg(ptr);
3416 return nativeResponseValue;
3419 export function LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(ptr: bigint): number {
3420 if(!isWasmInitialized) {
3421 throw new Error("initializeWasm() must be awaited first!");
3423 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(ptr);
3424 return nativeResponseValue;
3427 export function LDKMessageSendEvent_SendTxRemoveOutput_get_msg(ptr: bigint): bigint {
3428 if(!isWasmInitialized) {
3429 throw new Error("initializeWasm() must be awaited first!");
3431 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxRemoveOutput_get_msg(ptr);
3432 return nativeResponseValue;
3435 export function LDKMessageSendEvent_SendTxComplete_get_node_id(ptr: bigint): number {
3436 if(!isWasmInitialized) {
3437 throw new Error("initializeWasm() must be awaited first!");
3439 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxComplete_get_node_id(ptr);
3440 return nativeResponseValue;
3443 export function LDKMessageSendEvent_SendTxComplete_get_msg(ptr: bigint): bigint {
3444 if(!isWasmInitialized) {
3445 throw new Error("initializeWasm() must be awaited first!");
3447 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxComplete_get_msg(ptr);
3448 return nativeResponseValue;
3451 export function LDKMessageSendEvent_SendTxSignatures_get_node_id(ptr: bigint): number {
3452 if(!isWasmInitialized) {
3453 throw new Error("initializeWasm() must be awaited first!");
3455 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxSignatures_get_node_id(ptr);
3456 return nativeResponseValue;
3459 export function LDKMessageSendEvent_SendTxSignatures_get_msg(ptr: bigint): bigint {
3460 if(!isWasmInitialized) {
3461 throw new Error("initializeWasm() must be awaited first!");
3463 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxSignatures_get_msg(ptr);
3464 return nativeResponseValue;
3467 export function LDKMessageSendEvent_SendTxInitRbf_get_node_id(ptr: bigint): number {
3468 if(!isWasmInitialized) {
3469 throw new Error("initializeWasm() must be awaited first!");
3471 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxInitRbf_get_node_id(ptr);
3472 return nativeResponseValue;
3475 export function LDKMessageSendEvent_SendTxInitRbf_get_msg(ptr: bigint): bigint {
3476 if(!isWasmInitialized) {
3477 throw new Error("initializeWasm() must be awaited first!");
3479 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxInitRbf_get_msg(ptr);
3480 return nativeResponseValue;
3483 export function LDKMessageSendEvent_SendTxAckRbf_get_node_id(ptr: bigint): number {
3484 if(!isWasmInitialized) {
3485 throw new Error("initializeWasm() must be awaited first!");
3487 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAckRbf_get_node_id(ptr);
3488 return nativeResponseValue;
3491 export function LDKMessageSendEvent_SendTxAckRbf_get_msg(ptr: bigint): bigint {
3492 if(!isWasmInitialized) {
3493 throw new Error("initializeWasm() must be awaited first!");
3495 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAckRbf_get_msg(ptr);
3496 return nativeResponseValue;
3499 export function LDKMessageSendEvent_SendTxAbort_get_node_id(ptr: bigint): number {
3500 if(!isWasmInitialized) {
3501 throw new Error("initializeWasm() must be awaited first!");
3503 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAbort_get_node_id(ptr);
3504 return nativeResponseValue;
3507 export function LDKMessageSendEvent_SendTxAbort_get_msg(ptr: bigint): bigint {
3508 if(!isWasmInitialized) {
3509 throw new Error("initializeWasm() must be awaited first!");
3511 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendTxAbort_get_msg(ptr);
3512 return nativeResponseValue;
3515 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: bigint): number {
3516 if(!isWasmInitialized) {
3517 throw new Error("initializeWasm() must be awaited first!");
3519 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
3520 return nativeResponseValue;
3523 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: bigint): bigint {
3524 if(!isWasmInitialized) {
3525 throw new Error("initializeWasm() must be awaited first!");
3527 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
3528 return nativeResponseValue;
3531 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: bigint): number {
3532 if(!isWasmInitialized) {
3533 throw new Error("initializeWasm() must be awaited first!");
3535 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
3536 return nativeResponseValue;
3539 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: bigint): bigint {
3540 if(!isWasmInitialized) {
3541 throw new Error("initializeWasm() must be awaited first!");
3543 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
3544 return nativeResponseValue;
3547 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: bigint): number {
3548 if(!isWasmInitialized) {
3549 throw new Error("initializeWasm() must be awaited first!");
3551 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
3552 return nativeResponseValue;
3555 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: bigint): bigint {
3556 if(!isWasmInitialized) {
3557 throw new Error("initializeWasm() must be awaited first!");
3559 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
3560 return nativeResponseValue;
3563 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: bigint): number {
3564 if(!isWasmInitialized) {
3565 throw new Error("initializeWasm() must be awaited first!");
3567 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
3568 return nativeResponseValue;
3571 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: bigint): bigint {
3572 if(!isWasmInitialized) {
3573 throw new Error("initializeWasm() must be awaited first!");
3575 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
3576 return nativeResponseValue;
3579 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: bigint): number {
3580 if(!isWasmInitialized) {
3581 throw new Error("initializeWasm() must be awaited first!");
3583 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
3584 return nativeResponseValue;
3587 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: bigint): bigint {
3588 if(!isWasmInitialized) {
3589 throw new Error("initializeWasm() must be awaited first!");
3591 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
3592 return nativeResponseValue;
3595 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: bigint): number {
3596 if(!isWasmInitialized) {
3597 throw new Error("initializeWasm() must be awaited first!");
3599 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
3600 return nativeResponseValue;
3603 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: bigint): bigint {
3604 if(!isWasmInitialized) {
3605 throw new Error("initializeWasm() must be awaited first!");
3607 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
3608 return nativeResponseValue;
3611 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: bigint): number {
3612 if(!isWasmInitialized) {
3613 throw new Error("initializeWasm() must be awaited first!");
3615 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
3616 return nativeResponseValue;
3619 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: bigint): bigint {
3620 if(!isWasmInitialized) {
3621 throw new Error("initializeWasm() must be awaited first!");
3623 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
3624 return nativeResponseValue;
3627 export function LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr: bigint): number {
3628 if(!isWasmInitialized) {
3629 throw new Error("initializeWasm() must be awaited first!");
3631 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr);
3632 return nativeResponseValue;
3635 export function LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr: bigint): bigint {
3636 if(!isWasmInitialized) {
3637 throw new Error("initializeWasm() must be awaited first!");
3639 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr);
3640 return nativeResponseValue;
3643 export function LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
3644 if(!isWasmInitialized) {
3645 throw new Error("initializeWasm() must be awaited first!");
3647 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr);
3648 return nativeResponseValue;
3651 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: bigint): bigint {
3652 if(!isWasmInitialized) {
3653 throw new Error("initializeWasm() must be awaited first!");
3655 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
3656 return nativeResponseValue;
3659 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: bigint): bigint {
3660 if(!isWasmInitialized) {
3661 throw new Error("initializeWasm() must be awaited first!");
3663 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
3664 return nativeResponseValue;
3667 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: bigint): bigint {
3668 if(!isWasmInitialized) {
3669 throw new Error("initializeWasm() must be awaited first!");
3671 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
3672 return nativeResponseValue;
3675 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: bigint): bigint {
3676 if(!isWasmInitialized) {
3677 throw new Error("initializeWasm() must be awaited first!");
3679 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
3680 return nativeResponseValue;
3683 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: bigint): number {
3684 if(!isWasmInitialized) {
3685 throw new Error("initializeWasm() must be awaited first!");
3687 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
3688 return nativeResponseValue;
3691 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: bigint): bigint {
3692 if(!isWasmInitialized) {
3693 throw new Error("initializeWasm() must be awaited first!");
3695 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
3696 return nativeResponseValue;
3699 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: bigint): number {
3700 if(!isWasmInitialized) {
3701 throw new Error("initializeWasm() must be awaited first!");
3703 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
3704 return nativeResponseValue;
3707 export function LDKMessageSendEvent_HandleError_get_action(ptr: bigint): bigint {
3708 if(!isWasmInitialized) {
3709 throw new Error("initializeWasm() must be awaited first!");
3711 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
3712 return nativeResponseValue;
3715 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: bigint): number {
3716 if(!isWasmInitialized) {
3717 throw new Error("initializeWasm() must be awaited first!");
3719 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
3720 return nativeResponseValue;
3723 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: bigint): bigint {
3724 if(!isWasmInitialized) {
3725 throw new Error("initializeWasm() must be awaited first!");
3727 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
3728 return nativeResponseValue;
3731 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: bigint): number {
3732 if(!isWasmInitialized) {
3733 throw new Error("initializeWasm() must be awaited first!");
3735 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
3736 return nativeResponseValue;
3739 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: bigint): bigint {
3740 if(!isWasmInitialized) {
3741 throw new Error("initializeWasm() must be awaited first!");
3743 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
3744 return nativeResponseValue;
3747 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: bigint): number {
3748 if(!isWasmInitialized) {
3749 throw new Error("initializeWasm() must be awaited first!");
3751 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
3752 return nativeResponseValue;
3755 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: bigint): bigint {
3756 if(!isWasmInitialized) {
3757 throw new Error("initializeWasm() must be awaited first!");
3759 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
3760 return nativeResponseValue;
3763 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: bigint): number {
3764 if(!isWasmInitialized) {
3765 throw new Error("initializeWasm() must be awaited first!");
3767 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
3768 return nativeResponseValue;
3771 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: bigint): bigint {
3772 if(!isWasmInitialized) {
3773 throw new Error("initializeWasm() must be awaited first!");
3775 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
3776 return nativeResponseValue;
3778 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
3780 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3781 if(!isWasmInitialized) {
3782 throw new Error("initializeWasm() must be awaited first!");
3784 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
3785 return nativeResponseValue;
3787 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
3789 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3790 if(!isWasmInitialized) {
3791 throw new Error("initializeWasm() must be awaited first!");
3793 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
3794 return nativeResponseValue;
3796 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
3798 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3799 if(!isWasmInitialized) {
3800 throw new Error("initializeWasm() must be awaited first!");
3802 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
3803 return nativeResponseValue;
3805 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
3807 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3808 if(!isWasmInitialized) {
3809 throw new Error("initializeWasm() must be awaited first!");
3811 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
3812 return nativeResponseValue;
3814 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
3816 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: bigint): bigint {
3817 if(!isWasmInitialized) {
3818 throw new Error("initializeWasm() must be awaited first!");
3820 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
3821 return nativeResponseValue;
3823 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
3825 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: bigint): bigint {
3826 if(!isWasmInitialized) {
3827 throw new Error("initializeWasm() must be awaited first!");
3829 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
3830 return nativeResponseValue;
3833 export class LDKSocketAddress {
3834 protected constructor() {}
3837 export function LDKSocketAddress_ty_from_ptr(ptr: bigint): number {
3838 if(!isWasmInitialized) {
3839 throw new Error("initializeWasm() must be awaited first!");
3841 const nativeResponseValue = wasm.TS_LDKSocketAddress_ty_from_ptr(ptr);
3842 return nativeResponseValue;
3845 export function LDKSocketAddress_TcpIpV4_get_addr(ptr: bigint): number {
3846 if(!isWasmInitialized) {
3847 throw new Error("initializeWasm() must be awaited first!");
3849 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV4_get_addr(ptr);
3850 return nativeResponseValue;
3853 export function LDKSocketAddress_TcpIpV4_get_port(ptr: bigint): number {
3854 if(!isWasmInitialized) {
3855 throw new Error("initializeWasm() must be awaited first!");
3857 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV4_get_port(ptr);
3858 return nativeResponseValue;
3861 export function LDKSocketAddress_TcpIpV6_get_addr(ptr: bigint): number {
3862 if(!isWasmInitialized) {
3863 throw new Error("initializeWasm() must be awaited first!");
3865 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV6_get_addr(ptr);
3866 return nativeResponseValue;
3869 export function LDKSocketAddress_TcpIpV6_get_port(ptr: bigint): number {
3870 if(!isWasmInitialized) {
3871 throw new Error("initializeWasm() must be awaited first!");
3873 const nativeResponseValue = wasm.TS_LDKSocketAddress_TcpIpV6_get_port(ptr);
3874 return nativeResponseValue;
3877 export function LDKSocketAddress_OnionV2_get_onion_v2(ptr: bigint): number {
3878 if(!isWasmInitialized) {
3879 throw new Error("initializeWasm() must be awaited first!");
3881 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV2_get_onion_v2(ptr);
3882 return nativeResponseValue;
3885 export function LDKSocketAddress_OnionV3_get_ed25519_pubkey(ptr: bigint): number {
3886 if(!isWasmInitialized) {
3887 throw new Error("initializeWasm() must be awaited first!");
3889 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_ed25519_pubkey(ptr);
3890 return nativeResponseValue;
3893 export function LDKSocketAddress_OnionV3_get_checksum(ptr: bigint): number {
3894 if(!isWasmInitialized) {
3895 throw new Error("initializeWasm() must be awaited first!");
3897 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_checksum(ptr);
3898 return nativeResponseValue;
3901 export function LDKSocketAddress_OnionV3_get_version(ptr: bigint): number {
3902 if(!isWasmInitialized) {
3903 throw new Error("initializeWasm() must be awaited first!");
3905 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_version(ptr);
3906 return nativeResponseValue;
3909 export function LDKSocketAddress_OnionV3_get_port(ptr: bigint): number {
3910 if(!isWasmInitialized) {
3911 throw new Error("initializeWasm() must be awaited first!");
3913 const nativeResponseValue = wasm.TS_LDKSocketAddress_OnionV3_get_port(ptr);
3914 return nativeResponseValue;
3917 export function LDKSocketAddress_Hostname_get_hostname(ptr: bigint): bigint {
3918 if(!isWasmInitialized) {
3919 throw new Error("initializeWasm() must be awaited first!");
3921 const nativeResponseValue = wasm.TS_LDKSocketAddress_Hostname_get_hostname(ptr);
3922 return nativeResponseValue;
3925 export function LDKSocketAddress_Hostname_get_port(ptr: bigint): number {
3926 if(!isWasmInitialized) {
3927 throw new Error("initializeWasm() must be awaited first!");
3929 const nativeResponseValue = wasm.TS_LDKSocketAddress_Hostname_get_port(ptr);
3930 return nativeResponseValue;
3932 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3934 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3935 if(!isWasmInitialized) {
3936 throw new Error("initializeWasm() must be awaited first!");
3938 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
3939 return nativeResponseValue;
3941 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
3943 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3944 if(!isWasmInitialized) {
3945 throw new Error("initializeWasm() must be awaited first!");
3947 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
3948 return nativeResponseValue;
3950 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3952 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: bigint): bigint {
3953 if(!isWasmInitialized) {
3954 throw new Error("initializeWasm() must be awaited first!");
3956 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
3957 return nativeResponseValue;
3959 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
3961 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: bigint): bigint {
3962 if(!isWasmInitialized) {
3963 throw new Error("initializeWasm() must be awaited first!");
3965 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
3966 return nativeResponseValue;
3968 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3970 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
3971 if(!isWasmInitialized) {
3972 throw new Error("initializeWasm() must be awaited first!");
3974 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
3975 return nativeResponseValue;
3977 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3979 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: bigint): bigint {
3980 if(!isWasmInitialized) {
3981 throw new Error("initializeWasm() must be awaited first!");
3983 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
3984 return nativeResponseValue;
3986 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3988 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: bigint): bigint {
3989 if(!isWasmInitialized) {
3990 throw new Error("initializeWasm() must be awaited first!");
3992 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
3993 return nativeResponseValue;
3995 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3997 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: bigint): bigint {
3998 if(!isWasmInitialized) {
3999 throw new Error("initializeWasm() must be awaited first!");
4001 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
4002 return nativeResponseValue;
4005 export class LDKCOption_CVec_SocketAddressZZ {
4006 protected constructor() {}
4009 export function LDKCOption_CVec_SocketAddressZZ_ty_from_ptr(ptr: bigint): number {
4010 if(!isWasmInitialized) {
4011 throw new Error("initializeWasm() must be awaited first!");
4013 const nativeResponseValue = wasm.TS_LDKCOption_CVec_SocketAddressZZ_ty_from_ptr(ptr);
4014 return nativeResponseValue;
4017 export function LDKCOption_CVec_SocketAddressZZ_Some_get_some(ptr: bigint): number {
4018 if(!isWasmInitialized) {
4019 throw new Error("initializeWasm() must be awaited first!");
4021 const nativeResponseValue = wasm.TS_LDKCOption_CVec_SocketAddressZZ_Some_get_some(ptr);
4022 return nativeResponseValue;
4024 // struct LDKPendingHTLCInfo CResult_PendingHTLCInfoInboundHTLCErrZ_get_ok(LDKCResult_PendingHTLCInfoInboundHTLCErrZ *NONNULL_PTR owner);
4026 export function CResult_PendingHTLCInfoInboundHTLCErrZ_get_ok(owner: bigint): bigint {
4027 if(!isWasmInitialized) {
4028 throw new Error("initializeWasm() must be awaited first!");
4030 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_get_ok(owner);
4031 return nativeResponseValue;
4033 // struct LDKInboundHTLCErr CResult_PendingHTLCInfoInboundHTLCErrZ_get_err(LDKCResult_PendingHTLCInfoInboundHTLCErrZ *NONNULL_PTR owner);
4035 export function CResult_PendingHTLCInfoInboundHTLCErrZ_get_err(owner: bigint): bigint {
4036 if(!isWasmInitialized) {
4037 throw new Error("initializeWasm() must be awaited first!");
4039 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_get_err(owner);
4040 return nativeResponseValue;
4043 export class LDKCOption_TxOutZ {
4044 protected constructor() {}
4047 export function LDKCOption_TxOutZ_ty_from_ptr(ptr: bigint): number {
4048 if(!isWasmInitialized) {
4049 throw new Error("initializeWasm() must be awaited first!");
4051 const nativeResponseValue = wasm.TS_LDKCOption_TxOutZ_ty_from_ptr(ptr);
4052 return nativeResponseValue;
4055 export function LDKCOption_TxOutZ_Some_get_some(ptr: bigint): bigint {
4056 if(!isWasmInitialized) {
4057 throw new Error("initializeWasm() must be awaited first!");
4059 const nativeResponseValue = wasm.TS_LDKCOption_TxOutZ_Some_get_some(ptr);
4060 return nativeResponseValue;
4062 // struct LDKCoinSelection CResult_CoinSelectionNoneZ_get_ok(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner);
4064 export function CResult_CoinSelectionNoneZ_get_ok(owner: bigint): bigint {
4065 if(!isWasmInitialized) {
4066 throw new Error("initializeWasm() must be awaited first!");
4068 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_get_ok(owner);
4069 return nativeResponseValue;
4071 // void CResult_CoinSelectionNoneZ_get_err(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner);
4073 export function CResult_CoinSelectionNoneZ_get_err(owner: bigint): void {
4074 if(!isWasmInitialized) {
4075 throw new Error("initializeWasm() must be awaited first!");
4077 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_get_err(owner);
4078 // debug statements here
4080 // struct LDKCVec_UtxoZ CResult_CVec_UtxoZNoneZ_get_ok(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner);
4082 export function CResult_CVec_UtxoZNoneZ_get_ok(owner: bigint): number {
4083 if(!isWasmInitialized) {
4084 throw new Error("initializeWasm() must be awaited first!");
4086 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_get_ok(owner);
4087 return nativeResponseValue;
4089 // void CResult_CVec_UtxoZNoneZ_get_err(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner);
4091 export function CResult_CVec_UtxoZNoneZ_get_err(owner: bigint): void {
4092 if(!isWasmInitialized) {
4093 throw new Error("initializeWasm() must be awaited first!");
4095 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_get_err(owner);
4096 // debug statements here
4098 // uint64_t C2Tuple_u64u16Z_get_a(LDKC2Tuple_u64u16Z *NONNULL_PTR owner);
4100 export function C2Tuple_u64u16Z_get_a(owner: bigint): bigint {
4101 if(!isWasmInitialized) {
4102 throw new Error("initializeWasm() must be awaited first!");
4104 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_get_a(owner);
4105 return nativeResponseValue;
4107 // uint16_t C2Tuple_u64u16Z_get_b(LDKC2Tuple_u64u16Z *NONNULL_PTR owner);
4109 export function C2Tuple_u64u16Z_get_b(owner: bigint): number {
4110 if(!isWasmInitialized) {
4111 throw new Error("initializeWasm() must be awaited first!");
4113 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_get_b(owner);
4114 return nativeResponseValue;
4117 export class LDKCOption_C2Tuple_u64u16ZZ {
4118 protected constructor() {}
4121 export function LDKCOption_C2Tuple_u64u16ZZ_ty_from_ptr(ptr: bigint): number {
4122 if(!isWasmInitialized) {
4123 throw new Error("initializeWasm() must be awaited first!");
4125 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u16ZZ_ty_from_ptr(ptr);
4126 return nativeResponseValue;
4129 export function LDKCOption_C2Tuple_u64u16ZZ_Some_get_some(ptr: bigint): bigint {
4130 if(!isWasmInitialized) {
4131 throw new Error("initializeWasm() must be awaited first!");
4133 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u16ZZ_Some_get_some(ptr);
4134 return nativeResponseValue;
4137 export class LDKCOption_ChannelShutdownStateZ {
4138 protected constructor() {}
4141 export function LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr: bigint): number {
4142 if(!isWasmInitialized) {
4143 throw new Error("initializeWasm() must be awaited first!");
4145 const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr);
4146 return nativeResponseValue;
4149 export function LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr: bigint): ChannelShutdownState {
4150 if(!isWasmInitialized) {
4151 throw new Error("initializeWasm() must be awaited first!");
4153 const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr);
4154 return nativeResponseValue;
4156 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesAPIErrorZ_get_ok(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR owner);
4158 export function CResult_ThirtyTwoBytesAPIErrorZ_get_ok(owner: bigint): number {
4159 if(!isWasmInitialized) {
4160 throw new Error("initializeWasm() must be awaited first!");
4162 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_get_ok(owner);
4163 return nativeResponseValue;
4165 // struct LDKAPIError CResult_ThirtyTwoBytesAPIErrorZ_get_err(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR owner);
4167 export function CResult_ThirtyTwoBytesAPIErrorZ_get_err(owner: bigint): bigint {
4168 if(!isWasmInitialized) {
4169 throw new Error("initializeWasm() must be awaited first!");
4171 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_get_err(owner);
4172 return nativeResponseValue;
4175 export class LDKRecentPaymentDetails {
4176 protected constructor() {}
4179 export function LDKRecentPaymentDetails_ty_from_ptr(ptr: bigint): number {
4180 if(!isWasmInitialized) {
4181 throw new Error("initializeWasm() must be awaited first!");
4183 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_ty_from_ptr(ptr);
4184 return nativeResponseValue;
4187 export function LDKRecentPaymentDetails_AwaitingInvoice_get_payment_id(ptr: bigint): number {
4188 if(!isWasmInitialized) {
4189 throw new Error("initializeWasm() must be awaited first!");
4191 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_AwaitingInvoice_get_payment_id(ptr);
4192 return nativeResponseValue;
4195 export function LDKRecentPaymentDetails_Pending_get_payment_id(ptr: bigint): number {
4196 if(!isWasmInitialized) {
4197 throw new Error("initializeWasm() must be awaited first!");
4199 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_payment_id(ptr);
4200 return nativeResponseValue;
4203 export function LDKRecentPaymentDetails_Pending_get_payment_hash(ptr: bigint): number {
4204 if(!isWasmInitialized) {
4205 throw new Error("initializeWasm() must be awaited first!");
4207 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_payment_hash(ptr);
4208 return nativeResponseValue;
4211 export function LDKRecentPaymentDetails_Pending_get_total_msat(ptr: bigint): bigint {
4212 if(!isWasmInitialized) {
4213 throw new Error("initializeWasm() must be awaited first!");
4215 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Pending_get_total_msat(ptr);
4216 return nativeResponseValue;
4219 export function LDKRecentPaymentDetails_Fulfilled_get_payment_id(ptr: bigint): number {
4220 if(!isWasmInitialized) {
4221 throw new Error("initializeWasm() must be awaited first!");
4223 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Fulfilled_get_payment_id(ptr);
4224 return nativeResponseValue;
4227 export function LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr: bigint): bigint {
4228 if(!isWasmInitialized) {
4229 throw new Error("initializeWasm() must be awaited first!");
4231 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr);
4232 return nativeResponseValue;
4235 export function LDKRecentPaymentDetails_Abandoned_get_payment_id(ptr: bigint): number {
4236 if(!isWasmInitialized) {
4237 throw new Error("initializeWasm() must be awaited first!");
4239 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Abandoned_get_payment_id(ptr);
4240 return nativeResponseValue;
4243 export function LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr: bigint): number {
4244 if(!isWasmInitialized) {
4245 throw new Error("initializeWasm() must be awaited first!");
4247 const nativeResponseValue = wasm.TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr);
4248 return nativeResponseValue;
4251 export class LDKPaymentSendFailure {
4252 protected constructor() {}
4255 export function LDKPaymentSendFailure_ty_from_ptr(ptr: bigint): number {
4256 if(!isWasmInitialized) {
4257 throw new Error("initializeWasm() must be awaited first!");
4259 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
4260 return nativeResponseValue;
4263 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: bigint): bigint {
4264 if(!isWasmInitialized) {
4265 throw new Error("initializeWasm() must be awaited first!");
4267 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
4268 return nativeResponseValue;
4271 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: bigint): number {
4272 if(!isWasmInitialized) {
4273 throw new Error("initializeWasm() must be awaited first!");
4275 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
4276 return nativeResponseValue;
4279 export function LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr: bigint): number {
4280 if(!isWasmInitialized) {
4281 throw new Error("initializeWasm() must be awaited first!");
4283 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(ptr);
4284 return nativeResponseValue;
4287 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: bigint): number {
4288 if(!isWasmInitialized) {
4289 throw new Error("initializeWasm() must be awaited first!");
4291 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
4292 return nativeResponseValue;
4295 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: bigint): bigint {
4296 if(!isWasmInitialized) {
4297 throw new Error("initializeWasm() must be awaited first!");
4299 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
4300 return nativeResponseValue;
4303 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: bigint): number {
4304 if(!isWasmInitialized) {
4305 throw new Error("initializeWasm() must be awaited first!");
4307 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
4308 return nativeResponseValue;
4310 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4312 export function CResult_NonePaymentSendFailureZ_get_ok(owner: bigint): void {
4313 if(!isWasmInitialized) {
4314 throw new Error("initializeWasm() must be awaited first!");
4316 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
4317 // debug statements here
4319 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4321 export function CResult_NonePaymentSendFailureZ_get_err(owner: bigint): bigint {
4322 if(!isWasmInitialized) {
4323 throw new Error("initializeWasm() must be awaited first!");
4325 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
4326 return nativeResponseValue;
4328 // void CResult_NoneRetryableSendFailureZ_get_ok(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
4330 export function CResult_NoneRetryableSendFailureZ_get_ok(owner: bigint): void {
4331 if(!isWasmInitialized) {
4332 throw new Error("initializeWasm() must be awaited first!");
4334 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_ok(owner);
4335 // debug statements here
4337 // enum LDKRetryableSendFailure CResult_NoneRetryableSendFailureZ_get_err(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner);
4339 export function CResult_NoneRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
4340 if(!isWasmInitialized) {
4341 throw new Error("initializeWasm() must be awaited first!");
4343 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_get_err(owner);
4344 return nativeResponseValue;
4346 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR owner);
4348 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(owner: bigint): number {
4349 if(!isWasmInitialized) {
4350 throw new Error("initializeWasm() must be awaited first!");
4352 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(owner);
4353 return nativeResponseValue;
4355 // struct LDKPaymentSendFailure CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR owner);
4357 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(owner: bigint): bigint {
4358 if(!isWasmInitialized) {
4359 throw new Error("initializeWasm() must be awaited first!");
4361 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(owner);
4362 return nativeResponseValue;
4364 // struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR owner);
4366 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(owner: bigint): number {
4367 if(!isWasmInitialized) {
4368 throw new Error("initializeWasm() must be awaited first!");
4370 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(owner);
4371 return nativeResponseValue;
4373 // enum LDKRetryableSendFailure CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR owner);
4375 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(owner: bigint): RetryableSendFailure {
4376 if(!isWasmInitialized) {
4377 throw new Error("initializeWasm() must be awaited first!");
4379 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(owner);
4380 return nativeResponseValue;
4382 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR owner);
4384 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(owner: bigint): number {
4385 if(!isWasmInitialized) {
4386 throw new Error("initializeWasm() must be awaited first!");
4388 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(owner);
4389 return nativeResponseValue;
4391 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR owner);
4393 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(owner: bigint): number {
4394 if(!isWasmInitialized) {
4395 throw new Error("initializeWasm() must be awaited first!");
4397 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(owner);
4398 return nativeResponseValue;
4400 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR owner);
4402 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(owner: bigint): bigint {
4403 if(!isWasmInitialized) {
4404 throw new Error("initializeWasm() must be awaited first!");
4406 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(owner);
4407 return nativeResponseValue;
4409 // struct LDKPaymentSendFailure CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR owner);
4411 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(owner: bigint): bigint {
4412 if(!isWasmInitialized) {
4413 throw new Error("initializeWasm() must be awaited first!");
4415 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(owner);
4416 return nativeResponseValue;
4419 export class LDKProbeSendFailure {
4420 protected constructor() {}
4423 export function LDKProbeSendFailure_ty_from_ptr(ptr: bigint): number {
4424 if(!isWasmInitialized) {
4425 throw new Error("initializeWasm() must be awaited first!");
4427 const nativeResponseValue = wasm.TS_LDKProbeSendFailure_ty_from_ptr(ptr);
4428 return nativeResponseValue;
4431 export function LDKProbeSendFailure_SendingFailed_get_sending_failed(ptr: bigint): bigint {
4432 if(!isWasmInitialized) {
4433 throw new Error("initializeWasm() must be awaited first!");
4435 const nativeResponseValue = wasm.TS_LDKProbeSendFailure_SendingFailed_get_sending_failed(ptr);
4436 return nativeResponseValue;
4438 // struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR owner);
4440 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(owner: bigint): number {
4441 if(!isWasmInitialized) {
4442 throw new Error("initializeWasm() must be awaited first!");
4444 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(owner);
4445 return nativeResponseValue;
4447 // struct LDKProbeSendFailure CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR owner);
4449 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(owner: bigint): bigint {
4450 if(!isWasmInitialized) {
4451 throw new Error("initializeWasm() must be awaited first!");
4453 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(owner);
4454 return nativeResponseValue;
4456 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR owner);
4458 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(owner: bigint): number {
4459 if(!isWasmInitialized) {
4460 throw new Error("initializeWasm() must be awaited first!");
4462 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(owner);
4463 return nativeResponseValue;
4465 // struct LDKPublicKey C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR owner);
4467 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(owner: bigint): number {
4468 if(!isWasmInitialized) {
4469 throw new Error("initializeWasm() must be awaited first!");
4471 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(owner);
4472 return nativeResponseValue;
4475 export class LDKCOption_StrZ {
4476 protected constructor() {}
4479 export function LDKCOption_StrZ_ty_from_ptr(ptr: bigint): number {
4480 if(!isWasmInitialized) {
4481 throw new Error("initializeWasm() must be awaited first!");
4483 const nativeResponseValue = wasm.TS_LDKCOption_StrZ_ty_from_ptr(ptr);
4484 return nativeResponseValue;
4487 export function LDKCOption_StrZ_Some_get_some(ptr: bigint): number {
4488 if(!isWasmInitialized) {
4489 throw new Error("initializeWasm() must be awaited first!");
4491 const nativeResponseValue = wasm.TS_LDKCOption_StrZ_Some_get_some(ptr);
4492 return nativeResponseValue;
4494 // void CResult_NoneBolt12SemanticErrorZ_get_ok(LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR owner);
4496 export function CResult_NoneBolt12SemanticErrorZ_get_ok(owner: bigint): void {
4497 if(!isWasmInitialized) {
4498 throw new Error("initializeWasm() must be awaited first!");
4500 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_get_ok(owner);
4501 // debug statements here
4503 // enum LDKBolt12SemanticError CResult_NoneBolt12SemanticErrorZ_get_err(LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR owner);
4505 export function CResult_NoneBolt12SemanticErrorZ_get_err(owner: bigint): Bolt12SemanticError {
4506 if(!isWasmInitialized) {
4507 throw new Error("initializeWasm() must be awaited first!");
4509 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_get_err(owner);
4510 return nativeResponseValue;
4512 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR owner);
4514 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(owner: bigint): bigint {
4515 if(!isWasmInitialized) {
4516 throw new Error("initializeWasm() must be awaited first!");
4518 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(owner);
4519 return nativeResponseValue;
4521 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR owner);
4523 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(owner: bigint): void {
4524 if(!isWasmInitialized) {
4525 throw new Error("initializeWasm() must be awaited first!");
4527 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(owner);
4528 // debug statements here
4531 export class LDKOffersMessage {
4532 protected constructor() {}
4535 export function LDKOffersMessage_ty_from_ptr(ptr: bigint): number {
4536 if(!isWasmInitialized) {
4537 throw new Error("initializeWasm() must be awaited first!");
4539 const nativeResponseValue = wasm.TS_LDKOffersMessage_ty_from_ptr(ptr);
4540 return nativeResponseValue;
4543 export function LDKOffersMessage_InvoiceRequest_get_invoice_request(ptr: bigint): bigint {
4544 if(!isWasmInitialized) {
4545 throw new Error("initializeWasm() must be awaited first!");
4547 const nativeResponseValue = wasm.TS_LDKOffersMessage_InvoiceRequest_get_invoice_request(ptr);
4548 return nativeResponseValue;
4551 export function LDKOffersMessage_Invoice_get_invoice(ptr: bigint): bigint {
4552 if(!isWasmInitialized) {
4553 throw new Error("initializeWasm() must be awaited first!");
4555 const nativeResponseValue = wasm.TS_LDKOffersMessage_Invoice_get_invoice(ptr);
4556 return nativeResponseValue;
4559 export function LDKOffersMessage_InvoiceError_get_invoice_error(ptr: bigint): bigint {
4560 if(!isWasmInitialized) {
4561 throw new Error("initializeWasm() must be awaited first!");
4563 const nativeResponseValue = wasm.TS_LDKOffersMessage_InvoiceError_get_invoice_error(ptr);
4564 return nativeResponseValue;
4567 export class LDKCOption_OffersMessageZ {
4568 protected constructor() {}
4571 export function LDKCOption_OffersMessageZ_ty_from_ptr(ptr: bigint): number {
4572 if(!isWasmInitialized) {
4573 throw new Error("initializeWasm() must be awaited first!");
4575 const nativeResponseValue = wasm.TS_LDKCOption_OffersMessageZ_ty_from_ptr(ptr);
4576 return nativeResponseValue;
4579 export function LDKCOption_OffersMessageZ_Some_get_some(ptr: bigint): bigint {
4580 if(!isWasmInitialized) {
4581 throw new Error("initializeWasm() must be awaited first!");
4583 const nativeResponseValue = wasm.TS_LDKCOption_OffersMessageZ_Some_get_some(ptr);
4584 return nativeResponseValue;
4587 export class LDKDestination {
4588 protected constructor() {}
4591 export function LDKDestination_ty_from_ptr(ptr: bigint): number {
4592 if(!isWasmInitialized) {
4593 throw new Error("initializeWasm() must be awaited first!");
4595 const nativeResponseValue = wasm.TS_LDKDestination_ty_from_ptr(ptr);
4596 return nativeResponseValue;
4599 export function LDKDestination_Node_get_node(ptr: bigint): number {
4600 if(!isWasmInitialized) {
4601 throw new Error("initializeWasm() must be awaited first!");
4603 const nativeResponseValue = wasm.TS_LDKDestination_Node_get_node(ptr);
4604 return nativeResponseValue;
4607 export function LDKDestination_BlindedPath_get_blinded_path(ptr: bigint): bigint {
4608 if(!isWasmInitialized) {
4609 throw new Error("initializeWasm() must be awaited first!");
4611 const nativeResponseValue = wasm.TS_LDKDestination_BlindedPath_get_blinded_path(ptr);
4612 return nativeResponseValue;
4614 // struct LDKOffersMessage C3Tuple_OffersMessageDestinationBlindedPathZ_get_a(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR owner);
4616 export function C3Tuple_OffersMessageDestinationBlindedPathZ_get_a(owner: bigint): bigint {
4617 if(!isWasmInitialized) {
4618 throw new Error("initializeWasm() must be awaited first!");
4620 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_get_a(owner);
4621 return nativeResponseValue;
4623 // struct LDKDestination C3Tuple_OffersMessageDestinationBlindedPathZ_get_b(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR owner);
4625 export function C3Tuple_OffersMessageDestinationBlindedPathZ_get_b(owner: bigint): bigint {
4626 if(!isWasmInitialized) {
4627 throw new Error("initializeWasm() must be awaited first!");
4629 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_get_b(owner);
4630 return nativeResponseValue;
4632 // struct LDKBlindedPath C3Tuple_OffersMessageDestinationBlindedPathZ_get_c(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR owner);
4634 export function C3Tuple_OffersMessageDestinationBlindedPathZ_get_c(owner: bigint): bigint {
4635 if(!isWasmInitialized) {
4636 throw new Error("initializeWasm() must be awaited first!");
4638 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_get_c(owner);
4639 return nativeResponseValue;
4641 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4643 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4644 if(!isWasmInitialized) {
4645 throw new Error("initializeWasm() must be awaited first!");
4647 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
4648 return nativeResponseValue;
4650 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
4652 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4653 if(!isWasmInitialized) {
4654 throw new Error("initializeWasm() must be awaited first!");
4656 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
4657 return nativeResponseValue;
4659 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4661 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
4662 if(!isWasmInitialized) {
4663 throw new Error("initializeWasm() must be awaited first!");
4665 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
4666 return nativeResponseValue;
4668 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
4670 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
4671 if(!isWasmInitialized) {
4672 throw new Error("initializeWasm() must be awaited first!");
4674 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
4675 return nativeResponseValue;
4677 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4679 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
4680 if(!isWasmInitialized) {
4681 throw new Error("initializeWasm() must be awaited first!");
4683 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
4684 return nativeResponseValue;
4686 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
4688 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
4689 if(!isWasmInitialized) {
4690 throw new Error("initializeWasm() must be awaited first!");
4692 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
4693 return nativeResponseValue;
4695 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4697 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: bigint): bigint {
4698 if(!isWasmInitialized) {
4699 throw new Error("initializeWasm() must be awaited first!");
4701 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
4702 return nativeResponseValue;
4704 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
4706 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: bigint): bigint {
4707 if(!isWasmInitialized) {
4708 throw new Error("initializeWasm() must be awaited first!");
4710 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
4711 return nativeResponseValue;
4713 // struct LDKBlindedForward CResult_BlindedForwardDecodeErrorZ_get_ok(LDKCResult_BlindedForwardDecodeErrorZ *NONNULL_PTR owner);
4715 export function CResult_BlindedForwardDecodeErrorZ_get_ok(owner: bigint): bigint {
4716 if(!isWasmInitialized) {
4717 throw new Error("initializeWasm() must be awaited first!");
4719 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_get_ok(owner);
4720 return nativeResponseValue;
4722 // struct LDKDecodeError CResult_BlindedForwardDecodeErrorZ_get_err(LDKCResult_BlindedForwardDecodeErrorZ *NONNULL_PTR owner);
4724 export function CResult_BlindedForwardDecodeErrorZ_get_err(owner: bigint): bigint {
4725 if(!isWasmInitialized) {
4726 throw new Error("initializeWasm() must be awaited first!");
4728 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_get_err(owner);
4729 return nativeResponseValue;
4732 export class LDKPendingHTLCRouting {
4733 protected constructor() {}
4736 export function LDKPendingHTLCRouting_ty_from_ptr(ptr: bigint): number {
4737 if(!isWasmInitialized) {
4738 throw new Error("initializeWasm() must be awaited first!");
4740 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ty_from_ptr(ptr);
4741 return nativeResponseValue;
4744 export function LDKPendingHTLCRouting_Forward_get_onion_packet(ptr: bigint): bigint {
4745 if(!isWasmInitialized) {
4746 throw new Error("initializeWasm() must be awaited first!");
4748 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Forward_get_onion_packet(ptr);
4749 return nativeResponseValue;
4752 export function LDKPendingHTLCRouting_Forward_get_short_channel_id(ptr: bigint): bigint {
4753 if(!isWasmInitialized) {
4754 throw new Error("initializeWasm() must be awaited first!");
4756 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Forward_get_short_channel_id(ptr);
4757 return nativeResponseValue;
4760 export function LDKPendingHTLCRouting_Forward_get_blinded(ptr: bigint): bigint {
4761 if(!isWasmInitialized) {
4762 throw new Error("initializeWasm() must be awaited first!");
4764 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Forward_get_blinded(ptr);
4765 return nativeResponseValue;
4768 export function LDKPendingHTLCRouting_Receive_get_payment_data(ptr: bigint): bigint {
4769 if(!isWasmInitialized) {
4770 throw new Error("initializeWasm() must be awaited first!");
4772 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_payment_data(ptr);
4773 return nativeResponseValue;
4776 export function LDKPendingHTLCRouting_Receive_get_payment_metadata(ptr: bigint): bigint {
4777 if(!isWasmInitialized) {
4778 throw new Error("initializeWasm() must be awaited first!");
4780 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_payment_metadata(ptr);
4781 return nativeResponseValue;
4784 export function LDKPendingHTLCRouting_Receive_get_incoming_cltv_expiry(ptr: bigint): number {
4785 if(!isWasmInitialized) {
4786 throw new Error("initializeWasm() must be awaited first!");
4788 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_incoming_cltv_expiry(ptr);
4789 return nativeResponseValue;
4792 export function LDKPendingHTLCRouting_Receive_get_phantom_shared_secret(ptr: bigint): number {
4793 if(!isWasmInitialized) {
4794 throw new Error("initializeWasm() must be awaited first!");
4796 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_phantom_shared_secret(ptr);
4797 return nativeResponseValue;
4800 export function LDKPendingHTLCRouting_Receive_get_custom_tlvs(ptr: bigint): number {
4801 if(!isWasmInitialized) {
4802 throw new Error("initializeWasm() must be awaited first!");
4804 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_custom_tlvs(ptr);
4805 return nativeResponseValue;
4808 export function LDKPendingHTLCRouting_Receive_get_requires_blinded_error(ptr: bigint): boolean {
4809 if(!isWasmInitialized) {
4810 throw new Error("initializeWasm() must be awaited first!");
4812 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_Receive_get_requires_blinded_error(ptr);
4813 return nativeResponseValue;
4816 export function LDKPendingHTLCRouting_ReceiveKeysend_get_payment_data(ptr: bigint): bigint {
4817 if(!isWasmInitialized) {
4818 throw new Error("initializeWasm() must be awaited first!");
4820 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ReceiveKeysend_get_payment_data(ptr);
4821 return nativeResponseValue;
4824 export function LDKPendingHTLCRouting_ReceiveKeysend_get_payment_preimage(ptr: bigint): number {
4825 if(!isWasmInitialized) {
4826 throw new Error("initializeWasm() must be awaited first!");
4828 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ReceiveKeysend_get_payment_preimage(ptr);
4829 return nativeResponseValue;
4832 export function LDKPendingHTLCRouting_ReceiveKeysend_get_payment_metadata(ptr: bigint): bigint {
4833 if(!isWasmInitialized) {
4834 throw new Error("initializeWasm() must be awaited first!");
4836 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ReceiveKeysend_get_payment_metadata(ptr);
4837 return nativeResponseValue;
4840 export function LDKPendingHTLCRouting_ReceiveKeysend_get_incoming_cltv_expiry(ptr: bigint): number {
4841 if(!isWasmInitialized) {
4842 throw new Error("initializeWasm() must be awaited first!");
4844 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ReceiveKeysend_get_incoming_cltv_expiry(ptr);
4845 return nativeResponseValue;
4848 export function LDKPendingHTLCRouting_ReceiveKeysend_get_custom_tlvs(ptr: bigint): number {
4849 if(!isWasmInitialized) {
4850 throw new Error("initializeWasm() must be awaited first!");
4852 const nativeResponseValue = wasm.TS_LDKPendingHTLCRouting_ReceiveKeysend_get_custom_tlvs(ptr);
4853 return nativeResponseValue;
4855 // struct LDKPendingHTLCRouting CResult_PendingHTLCRoutingDecodeErrorZ_get_ok(LDKCResult_PendingHTLCRoutingDecodeErrorZ *NONNULL_PTR owner);
4857 export function CResult_PendingHTLCRoutingDecodeErrorZ_get_ok(owner: bigint): bigint {
4858 if(!isWasmInitialized) {
4859 throw new Error("initializeWasm() must be awaited first!");
4861 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_get_ok(owner);
4862 return nativeResponseValue;
4864 // struct LDKDecodeError CResult_PendingHTLCRoutingDecodeErrorZ_get_err(LDKCResult_PendingHTLCRoutingDecodeErrorZ *NONNULL_PTR owner);
4866 export function CResult_PendingHTLCRoutingDecodeErrorZ_get_err(owner: bigint): bigint {
4867 if(!isWasmInitialized) {
4868 throw new Error("initializeWasm() must be awaited first!");
4870 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_get_err(owner);
4871 return nativeResponseValue;
4873 // struct LDKPendingHTLCInfo CResult_PendingHTLCInfoDecodeErrorZ_get_ok(LDKCResult_PendingHTLCInfoDecodeErrorZ *NONNULL_PTR owner);
4875 export function CResult_PendingHTLCInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
4876 if(!isWasmInitialized) {
4877 throw new Error("initializeWasm() must be awaited first!");
4879 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_get_ok(owner);
4880 return nativeResponseValue;
4882 // struct LDKDecodeError CResult_PendingHTLCInfoDecodeErrorZ_get_err(LDKCResult_PendingHTLCInfoDecodeErrorZ *NONNULL_PTR owner);
4884 export function CResult_PendingHTLCInfoDecodeErrorZ_get_err(owner: bigint): bigint {
4885 if(!isWasmInitialized) {
4886 throw new Error("initializeWasm() must be awaited first!");
4888 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_get_err(owner);
4889 return nativeResponseValue;
4891 // enum LDKBlindedFailure CResult_BlindedFailureDecodeErrorZ_get_ok(LDKCResult_BlindedFailureDecodeErrorZ *NONNULL_PTR owner);
4893 export function CResult_BlindedFailureDecodeErrorZ_get_ok(owner: bigint): BlindedFailure {
4894 if(!isWasmInitialized) {
4895 throw new Error("initializeWasm() must be awaited first!");
4897 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_get_ok(owner);
4898 return nativeResponseValue;
4900 // struct LDKDecodeError CResult_BlindedFailureDecodeErrorZ_get_err(LDKCResult_BlindedFailureDecodeErrorZ *NONNULL_PTR owner);
4902 export function CResult_BlindedFailureDecodeErrorZ_get_err(owner: bigint): bigint {
4903 if(!isWasmInitialized) {
4904 throw new Error("initializeWasm() must be awaited first!");
4906 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_get_err(owner);
4907 return nativeResponseValue;
4909 // enum LDKChannelShutdownState CResult_ChannelShutdownStateDecodeErrorZ_get_ok(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
4911 export function CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner: bigint): ChannelShutdownState {
4912 if(!isWasmInitialized) {
4913 throw new Error("initializeWasm() must be awaited first!");
4915 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner);
4916 return nativeResponseValue;
4918 // struct LDKDecodeError CResult_ChannelShutdownStateDecodeErrorZ_get_err(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
4920 export function CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner: bigint): bigint {
4921 if(!isWasmInitialized) {
4922 throw new Error("initializeWasm() must be awaited first!");
4924 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner);
4925 return nativeResponseValue;
4928 export interface LDKWatch {
4929 watch_channel (funding_txo: bigint, monitor: bigint): bigint;
4930 update_channel (funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus;
4931 release_pending_monitor_events (): number;
4935 export function LDKWatch_new(impl: LDKWatch): [bigint, number] {
4936 if(!isWasmInitialized) {
4937 throw new Error("initializeWasm() must be awaited first!");
4939 var new_obj_idx = js_objs.length;
4940 for (var i = 0; i < js_objs.length; i++) {
4941 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4943 js_objs[i] = new WeakRef(impl);
4944 return [wasm.TS_LDKWatch_new(i), i];
4946 // LDKCResult_ChannelMonitorUpdateStatusNoneZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
4948 export function Watch_watch_channel(this_arg: bigint, funding_txo: bigint, monitor: bigint): bigint {
4949 if(!isWasmInitialized) {
4950 throw new Error("initializeWasm() must be awaited first!");
4952 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
4953 return nativeResponseValue;
4955 // LDKChannelMonitorUpdateStatus Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update
4957 export function Watch_update_channel(this_arg: bigint, funding_txo: bigint, update: bigint): ChannelMonitorUpdateStatus {
4958 if(!isWasmInitialized) {
4959 throw new Error("initializeWasm() must be awaited first!");
4961 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
4962 return nativeResponseValue;
4964 // LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
4966 export function Watch_release_pending_monitor_events(this_arg: bigint): number {
4967 if(!isWasmInitialized) {
4968 throw new Error("initializeWasm() must be awaited first!");
4970 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
4971 return nativeResponseValue;
4974 export interface LDKBroadcasterInterface {
4975 broadcast_transactions (txs: number): void;
4979 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): [bigint, number] {
4980 if(!isWasmInitialized) {
4981 throw new Error("initializeWasm() must be awaited first!");
4983 var new_obj_idx = js_objs.length;
4984 for (var i = 0; i < js_objs.length; i++) {
4985 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4987 js_objs[i] = new WeakRef(impl);
4988 return [wasm.TS_LDKBroadcasterInterface_new(i), i];
4990 // void BroadcasterInterface_broadcast_transactions LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKCVec_TransactionZ txs
4992 export function BroadcasterInterface_broadcast_transactions(this_arg: bigint, txs: number): void {
4993 if(!isWasmInitialized) {
4994 throw new Error("initializeWasm() must be awaited first!");
4996 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transactions(this_arg, txs);
4997 // debug statements here
5000 export interface LDKEntropySource {
5001 get_secure_random_bytes (): number;
5005 export function LDKEntropySource_new(impl: LDKEntropySource): [bigint, number] {
5006 if(!isWasmInitialized) {
5007 throw new Error("initializeWasm() must be awaited first!");
5009 var new_obj_idx = js_objs.length;
5010 for (var i = 0; i < js_objs.length; i++) {
5011 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5013 js_objs[i] = new WeakRef(impl);
5014 return [wasm.TS_LDKEntropySource_new(i), i];
5016 // LDKThirtyTwoBytes EntropySource_get_secure_random_bytes LDKEntropySource *NONNULL_PTR this_arg
5018 export function EntropySource_get_secure_random_bytes(this_arg: bigint): number {
5019 if(!isWasmInitialized) {
5020 throw new Error("initializeWasm() must be awaited first!");
5022 const nativeResponseValue = wasm.TS_EntropySource_get_secure_random_bytes(this_arg);
5023 return nativeResponseValue;
5026 export class LDKUnsignedGossipMessage {
5027 protected constructor() {}
5030 export function LDKUnsignedGossipMessage_ty_from_ptr(ptr: bigint): number {
5031 if(!isWasmInitialized) {
5032 throw new Error("initializeWasm() must be awaited first!");
5034 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ty_from_ptr(ptr);
5035 return nativeResponseValue;
5038 export function LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr: bigint): bigint {
5039 if(!isWasmInitialized) {
5040 throw new Error("initializeWasm() must be awaited first!");
5042 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(ptr);
5043 return nativeResponseValue;
5046 export function LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr: bigint): bigint {
5047 if(!isWasmInitialized) {
5048 throw new Error("initializeWasm() must be awaited first!");
5050 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(ptr);
5051 return nativeResponseValue;
5054 export function LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr: bigint): bigint {
5055 if(!isWasmInitialized) {
5056 throw new Error("initializeWasm() must be awaited first!");
5058 const nativeResponseValue = wasm.TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(ptr);
5059 return nativeResponseValue;
5062 export interface LDKNodeSigner {
5063 get_inbound_payment_key_material (): number;
5064 get_node_id (recipient: Recipient): bigint;
5065 ecdh (recipient: Recipient, other_key: number, tweak: bigint): bigint;
5066 sign_invoice (hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint;
5067 sign_bolt12_invoice_request (invoice_request: bigint): bigint;
5068 sign_bolt12_invoice (invoice: bigint): bigint;
5069 sign_gossip_message (msg: bigint): bigint;
5073 export function LDKNodeSigner_new(impl: LDKNodeSigner): [bigint, number] {
5074 if(!isWasmInitialized) {
5075 throw new Error("initializeWasm() must be awaited first!");
5077 var new_obj_idx = js_objs.length;
5078 for (var i = 0; i < js_objs.length; i++) {
5079 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5081 js_objs[i] = new WeakRef(impl);
5082 return [wasm.TS_LDKNodeSigner_new(i), i];
5084 // LDKThirtyTwoBytes NodeSigner_get_inbound_payment_key_material LDKNodeSigner *NONNULL_PTR this_arg
5086 export function NodeSigner_get_inbound_payment_key_material(this_arg: bigint): number {
5087 if(!isWasmInitialized) {
5088 throw new Error("initializeWasm() must be awaited first!");
5090 const nativeResponseValue = wasm.TS_NodeSigner_get_inbound_payment_key_material(this_arg);
5091 return nativeResponseValue;
5093 // LDKCResult_PublicKeyNoneZ NodeSigner_get_node_id LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient
5095 export function NodeSigner_get_node_id(this_arg: bigint, recipient: Recipient): bigint {
5096 if(!isWasmInitialized) {
5097 throw new Error("initializeWasm() must be awaited first!");
5099 const nativeResponseValue = wasm.TS_NodeSigner_get_node_id(this_arg, recipient);
5100 return nativeResponseValue;
5102 // LDKCResult_ThirtyTwoBytesNoneZ NodeSigner_ecdh LDKNodeSigner *NONNULL_PTR this_arg, enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak
5104 export function NodeSigner_ecdh(this_arg: bigint, recipient: Recipient, other_key: number, tweak: bigint): bigint {
5105 if(!isWasmInitialized) {
5106 throw new Error("initializeWasm() must be awaited first!");
5108 const nativeResponseValue = wasm.TS_NodeSigner_ecdh(this_arg, recipient, other_key, tweak);
5109 return nativeResponseValue;
5111 // LDKCResult_RecoverableSignatureNoneZ NodeSigner_sign_invoice LDKNodeSigner *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient
5113 export function NodeSigner_sign_invoice(this_arg: bigint, hrp_bytes: number, invoice_data: number, recipient: Recipient): bigint {
5114 if(!isWasmInitialized) {
5115 throw new Error("initializeWasm() must be awaited first!");
5117 const nativeResponseValue = wasm.TS_NodeSigner_sign_invoice(this_arg, hrp_bytes, invoice_data, recipient);
5118 return nativeResponseValue;
5120 // LDKCResult_SchnorrSignatureNoneZ NodeSigner_sign_bolt12_invoice_request LDKNodeSigner *NONNULL_PTR this_arg, const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request
5122 export function NodeSigner_sign_bolt12_invoice_request(this_arg: bigint, invoice_request: bigint): bigint {
5123 if(!isWasmInitialized) {
5124 throw new Error("initializeWasm() must be awaited first!");
5126 const nativeResponseValue = wasm.TS_NodeSigner_sign_bolt12_invoice_request(this_arg, invoice_request);
5127 return nativeResponseValue;
5129 // LDKCResult_SchnorrSignatureNoneZ NodeSigner_sign_bolt12_invoice LDKNodeSigner *NONNULL_PTR this_arg, const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice
5131 export function NodeSigner_sign_bolt12_invoice(this_arg: bigint, invoice: bigint): bigint {
5132 if(!isWasmInitialized) {
5133 throw new Error("initializeWasm() must be awaited first!");
5135 const nativeResponseValue = wasm.TS_NodeSigner_sign_bolt12_invoice(this_arg, invoice);
5136 return nativeResponseValue;
5138 // LDKCResult_ECDSASignatureNoneZ NodeSigner_sign_gossip_message LDKNodeSigner *NONNULL_PTR this_arg, struct LDKUnsignedGossipMessage msg
5140 export function NodeSigner_sign_gossip_message(this_arg: bigint, msg: bigint): bigint {
5141 if(!isWasmInitialized) {
5142 throw new Error("initializeWasm() must be awaited first!");
5144 const nativeResponseValue = wasm.TS_NodeSigner_sign_gossip_message(this_arg, msg);
5145 return nativeResponseValue;
5148 export interface LDKSignerProvider {
5149 generate_channel_keys_id (inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number;
5150 derive_channel_signer (channel_value_satoshis: bigint, channel_keys_id: number): bigint;
5151 read_chan_signer (reader: number): bigint;
5152 get_destination_script (channel_keys_id: number): bigint;
5153 get_shutdown_scriptpubkey (): bigint;
5157 export function LDKSignerProvider_new(impl: LDKSignerProvider): [bigint, number] {
5158 if(!isWasmInitialized) {
5159 throw new Error("initializeWasm() must be awaited first!");
5161 var new_obj_idx = js_objs.length;
5162 for (var i = 0; i < js_objs.length; i++) {
5163 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5165 js_objs[i] = new WeakRef(impl);
5166 return [wasm.TS_LDKSignerProvider_new(i), i];
5168 // LDKThirtyTwoBytes SignerProvider_generate_channel_keys_id LDKSignerProvider *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id
5170 export function SignerProvider_generate_channel_keys_id(this_arg: bigint, inbound: boolean, channel_value_satoshis: bigint, user_channel_id: number): number {
5171 if(!isWasmInitialized) {
5172 throw new Error("initializeWasm() must be awaited first!");
5174 const nativeResponseValue = wasm.TS_SignerProvider_generate_channel_keys_id(this_arg, inbound, channel_value_satoshis, user_channel_id);
5175 return nativeResponseValue;
5177 // LDKWriteableEcdsaChannelSigner SignerProvider_derive_channel_signer LDKSignerProvider *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id
5179 export function SignerProvider_derive_channel_signer(this_arg: bigint, channel_value_satoshis: bigint, channel_keys_id: number): bigint {
5180 if(!isWasmInitialized) {
5181 throw new Error("initializeWasm() must be awaited first!");
5183 const nativeResponseValue = wasm.TS_SignerProvider_derive_channel_signer(this_arg, channel_value_satoshis, channel_keys_id);
5184 return nativeResponseValue;
5186 // LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider_read_chan_signer LDKSignerProvider *NONNULL_PTR this_arg, struct LDKu8slice reader
5188 export function SignerProvider_read_chan_signer(this_arg: bigint, reader: number): bigint {
5189 if(!isWasmInitialized) {
5190 throw new Error("initializeWasm() must be awaited first!");
5192 const nativeResponseValue = wasm.TS_SignerProvider_read_chan_signer(this_arg, reader);
5193 return nativeResponseValue;
5195 // LDKCResult_CVec_u8ZNoneZ SignerProvider_get_destination_script LDKSignerProvider *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes channel_keys_id
5197 export function SignerProvider_get_destination_script(this_arg: bigint, channel_keys_id: number): bigint {
5198 if(!isWasmInitialized) {
5199 throw new Error("initializeWasm() must be awaited first!");
5201 const nativeResponseValue = wasm.TS_SignerProvider_get_destination_script(this_arg, channel_keys_id);
5202 return nativeResponseValue;
5204 // LDKCResult_ShutdownScriptNoneZ SignerProvider_get_shutdown_scriptpubkey LDKSignerProvider *NONNULL_PTR this_arg
5206 export function SignerProvider_get_shutdown_scriptpubkey(this_arg: bigint): bigint {
5207 if(!isWasmInitialized) {
5208 throw new Error("initializeWasm() must be awaited first!");
5210 const nativeResponseValue = wasm.TS_SignerProvider_get_shutdown_scriptpubkey(this_arg);
5211 return nativeResponseValue;
5214 export interface LDKFeeEstimator {
5215 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
5219 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): [bigint, number] {
5220 if(!isWasmInitialized) {
5221 throw new Error("initializeWasm() must be awaited first!");
5223 var new_obj_idx = js_objs.length;
5224 for (var i = 0; i < js_objs.length; i++) {
5225 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5227 js_objs[i] = new WeakRef(impl);
5228 return [wasm.TS_LDKFeeEstimator_new(i), i];
5230 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
5232 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: bigint, confirmation_target: ConfirmationTarget): number {
5233 if(!isWasmInitialized) {
5234 throw new Error("initializeWasm() must be awaited first!");
5236 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
5237 return nativeResponseValue;
5240 export interface LDKMessageRouter {
5241 find_path (sender: number, peers: number, destination: bigint): bigint;
5242 create_blinded_paths (recipient: number, peers: number): bigint;
5246 export function LDKMessageRouter_new(impl: LDKMessageRouter): [bigint, number] {
5247 if(!isWasmInitialized) {
5248 throw new Error("initializeWasm() must be awaited first!");
5250 var new_obj_idx = js_objs.length;
5251 for (var i = 0; i < js_objs.length; i++) {
5252 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5254 js_objs[i] = new WeakRef(impl);
5255 return [wasm.TS_LDKMessageRouter_new(i), i];
5257 // LDKCResult_OnionMessagePathNoneZ MessageRouter_find_path LDKMessageRouter *NONNULL_PTR this_arg, struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination
5259 export function MessageRouter_find_path(this_arg: bigint, sender: number, peers: number, destination: bigint): bigint {
5260 if(!isWasmInitialized) {
5261 throw new Error("initializeWasm() must be awaited first!");
5263 const nativeResponseValue = wasm.TS_MessageRouter_find_path(this_arg, sender, peers, destination);
5264 return nativeResponseValue;
5266 // LDKCResult_CVec_BlindedPathZNoneZ MessageRouter_create_blinded_paths LDKMessageRouter *NONNULL_PTR this_arg, struct LDKPublicKey recipient, struct LDKCVec_PublicKeyZ peers
5268 export function MessageRouter_create_blinded_paths(this_arg: bigint, recipient: number, peers: number): bigint {
5269 if(!isWasmInitialized) {
5270 throw new Error("initializeWasm() must be awaited first!");
5272 const nativeResponseValue = wasm.TS_MessageRouter_create_blinded_paths(this_arg, recipient, peers);
5273 return nativeResponseValue;
5276 export interface LDKRouter {
5277 find_route (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint;
5278 find_route_with_id (payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint, _payment_hash: number, _payment_id: number): bigint;
5279 create_blinded_payment_paths (recipient: number, first_hops: number, tlvs: bigint, amount_msats: bigint): bigint;
5283 export function LDKRouter_new(impl: LDKRouter, MessageRouter: number): [bigint, number] {
5284 if(!isWasmInitialized) {
5285 throw new Error("initializeWasm() must be awaited first!");
5287 var new_obj_idx = js_objs.length;
5288 for (var i = 0; i < js_objs.length; i++) {
5289 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5291 js_objs[i] = new WeakRef(impl);
5292 return [wasm.TS_LDKRouter_new(i, MessageRouter), i];
5294 // 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
5296 export function Router_find_route(this_arg: bigint, payer: number, route_params: bigint, first_hops: number, inflight_htlcs: bigint): bigint {
5297 if(!isWasmInitialized) {
5298 throw new Error("initializeWasm() must be awaited first!");
5300 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, first_hops, inflight_htlcs);
5301 return nativeResponseValue;
5303 // 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
5305 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 {
5306 if(!isWasmInitialized) {
5307 throw new Error("initializeWasm() must be awaited first!");
5309 const nativeResponseValue = wasm.TS_Router_find_route_with_id(this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
5310 return nativeResponseValue;
5312 // LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ Router_create_blinded_payment_paths LDKRouter *NONNULL_PTR this_arg, struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats
5314 export function Router_create_blinded_payment_paths(this_arg: bigint, recipient: number, first_hops: number, tlvs: bigint, amount_msats: bigint): bigint {
5315 if(!isWasmInitialized) {
5316 throw new Error("initializeWasm() must be awaited first!");
5318 const nativeResponseValue = wasm.TS_Router_create_blinded_payment_paths(this_arg, recipient, first_hops, tlvs, amount_msats);
5319 return nativeResponseValue;
5321 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *NONNULL_PTR owner);
5323 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(owner: bigint): number {
5324 if(!isWasmInitialized) {
5325 throw new Error("initializeWasm() must be awaited first!");
5327 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(owner);
5328 return nativeResponseValue;
5330 // struct LDKChannelManager C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *NONNULL_PTR owner);
5332 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(owner: bigint): bigint {
5333 if(!isWasmInitialized) {
5334 throw new Error("initializeWasm() must be awaited first!");
5336 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(owner);
5337 return nativeResponseValue;
5339 // struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
5341 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(owner: bigint): bigint {
5342 if(!isWasmInitialized) {
5343 throw new Error("initializeWasm() must be awaited first!");
5345 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(owner);
5346 return nativeResponseValue;
5348 // struct LDKDecodeError CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
5350 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(owner: bigint): bigint {
5351 if(!isWasmInitialized) {
5352 throw new Error("initializeWasm() must be awaited first!");
5354 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(owner);
5355 return nativeResponseValue;
5358 export class LDKMaxDustHTLCExposure {
5359 protected constructor() {}
5362 export function LDKMaxDustHTLCExposure_ty_from_ptr(ptr: bigint): number {
5363 if(!isWasmInitialized) {
5364 throw new Error("initializeWasm() must be awaited first!");
5366 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_ty_from_ptr(ptr);
5367 return nativeResponseValue;
5370 export function LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat(ptr: bigint): bigint {
5371 if(!isWasmInitialized) {
5372 throw new Error("initializeWasm() must be awaited first!");
5374 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat(ptr);
5375 return nativeResponseValue;
5378 export function LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier(ptr: bigint): bigint {
5379 if(!isWasmInitialized) {
5380 throw new Error("initializeWasm() must be awaited first!");
5382 const nativeResponseValue = wasm.TS_LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier(ptr);
5383 return nativeResponseValue;
5385 // struct LDKMaxDustHTLCExposure CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner);
5387 export function CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(owner: bigint): bigint {
5388 if(!isWasmInitialized) {
5389 throw new Error("initializeWasm() must be awaited first!");
5391 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(owner);
5392 return nativeResponseValue;
5394 // struct LDKDecodeError CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner);
5396 export function CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(owner: bigint): bigint {
5397 if(!isWasmInitialized) {
5398 throw new Error("initializeWasm() must be awaited first!");
5400 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(owner);
5401 return nativeResponseValue;
5403 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
5405 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: bigint): bigint {
5406 if(!isWasmInitialized) {
5407 throw new Error("initializeWasm() must be awaited first!");
5409 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
5410 return nativeResponseValue;
5412 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
5414 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: bigint): bigint {
5415 if(!isWasmInitialized) {
5416 throw new Error("initializeWasm() must be awaited first!");
5418 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
5419 return nativeResponseValue;
5422 export class LDKCOption_MaxDustHTLCExposureZ {
5423 protected constructor() {}
5426 export function LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr(ptr: bigint): number {
5427 if(!isWasmInitialized) {
5428 throw new Error("initializeWasm() must be awaited first!");
5430 const nativeResponseValue = wasm.TS_LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr(ptr);
5431 return nativeResponseValue;
5434 export function LDKCOption_MaxDustHTLCExposureZ_Some_get_some(ptr: bigint): bigint {
5435 if(!isWasmInitialized) {
5436 throw new Error("initializeWasm() must be awaited first!");
5438 const nativeResponseValue = wasm.TS_LDKCOption_MaxDustHTLCExposureZ_Some_get_some(ptr);
5439 return nativeResponseValue;
5442 export class LDKCOption_APIErrorZ {
5443 protected constructor() {}
5446 export function LDKCOption_APIErrorZ_ty_from_ptr(ptr: bigint): number {
5447 if(!isWasmInitialized) {
5448 throw new Error("initializeWasm() must be awaited first!");
5450 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_ty_from_ptr(ptr);
5451 return nativeResponseValue;
5454 export function LDKCOption_APIErrorZ_Some_get_some(ptr: bigint): bigint {
5455 if(!isWasmInitialized) {
5456 throw new Error("initializeWasm() must be awaited first!");
5458 const nativeResponseValue = wasm.TS_LDKCOption_APIErrorZ_Some_get_some(ptr);
5459 return nativeResponseValue;
5461 // struct LDKCOption_APIErrorZ CResult_COption_APIErrorZDecodeErrorZ_get_ok(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
5463 export function CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner: bigint): bigint {
5464 if(!isWasmInitialized) {
5465 throw new Error("initializeWasm() must be awaited first!");
5467 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner);
5468 return nativeResponseValue;
5470 // struct LDKDecodeError CResult_COption_APIErrorZDecodeErrorZ_get_err(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner);
5472 export function CResult_COption_APIErrorZDecodeErrorZ_get_err(owner: bigint): bigint {
5473 if(!isWasmInitialized) {
5474 throw new Error("initializeWasm() must be awaited first!");
5476 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_get_err(owner);
5477 return nativeResponseValue;
5479 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
5481 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5482 if(!isWasmInitialized) {
5483 throw new Error("initializeWasm() must be awaited first!");
5485 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
5486 return nativeResponseValue;
5488 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
5490 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5491 if(!isWasmInitialized) {
5492 throw new Error("initializeWasm() must be awaited first!");
5494 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
5495 return nativeResponseValue;
5498 export class LDKCOption_MonitorEventZ {
5499 protected constructor() {}
5502 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: bigint): number {
5503 if(!isWasmInitialized) {
5504 throw new Error("initializeWasm() must be awaited first!");
5506 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
5507 return nativeResponseValue;
5510 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: bigint): bigint {
5511 if(!isWasmInitialized) {
5512 throw new Error("initializeWasm() must be awaited first!");
5514 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
5515 return nativeResponseValue;
5517 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
5519 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: bigint): bigint {
5520 if(!isWasmInitialized) {
5521 throw new Error("initializeWasm() must be awaited first!");
5523 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
5524 return nativeResponseValue;
5526 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
5528 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: bigint): bigint {
5529 if(!isWasmInitialized) {
5530 throw new Error("initializeWasm() must be awaited first!");
5532 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
5533 return nativeResponseValue;
5535 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
5537 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
5538 if(!isWasmInitialized) {
5539 throw new Error("initializeWasm() must be awaited first!");
5541 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
5542 return nativeResponseValue;
5544 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
5546 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
5547 if(!isWasmInitialized) {
5548 throw new Error("initializeWasm() must be awaited first!");
5550 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
5551 return nativeResponseValue;
5553 // struct LDKOutPoint C2Tuple_OutPointCVec_u8ZZ_get_a(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR owner);
5555 export function C2Tuple_OutPointCVec_u8ZZ_get_a(owner: bigint): bigint {
5556 if(!isWasmInitialized) {
5557 throw new Error("initializeWasm() must be awaited first!");
5559 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_get_a(owner);
5560 return nativeResponseValue;
5562 // struct LDKCVec_u8Z C2Tuple_OutPointCVec_u8ZZ_get_b(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR owner);
5564 export function C2Tuple_OutPointCVec_u8ZZ_get_b(owner: bigint): number {
5565 if(!isWasmInitialized) {
5566 throw new Error("initializeWasm() must be awaited first!");
5568 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_get_b(owner);
5569 return nativeResponseValue;
5571 // uint32_t C2Tuple_u32CVec_u8ZZ_get_a(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR owner);
5573 export function C2Tuple_u32CVec_u8ZZ_get_a(owner: bigint): number {
5574 if(!isWasmInitialized) {
5575 throw new Error("initializeWasm() must be awaited first!");
5577 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_get_a(owner);
5578 return nativeResponseValue;
5580 // struct LDKCVec_u8Z C2Tuple_u32CVec_u8ZZ_get_b(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR owner);
5582 export function C2Tuple_u32CVec_u8ZZ_get_b(owner: bigint): number {
5583 if(!isWasmInitialized) {
5584 throw new Error("initializeWasm() must be awaited first!");
5586 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_get_b(owner);
5587 return nativeResponseValue;
5589 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR owner);
5591 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(owner: bigint): number {
5592 if(!isWasmInitialized) {
5593 throw new Error("initializeWasm() must be awaited first!");
5595 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(owner);
5596 return nativeResponseValue;
5598 // struct LDKCVec_C2Tuple_u32CVec_u8ZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR owner);
5600 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(owner: bigint): number {
5601 if(!isWasmInitialized) {
5602 throw new Error("initializeWasm() must be awaited first!");
5604 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(owner);
5605 return nativeResponseValue;
5607 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
5609 export function C2Tuple_u32TxOutZ_get_a(owner: bigint): number {
5610 if(!isWasmInitialized) {
5611 throw new Error("initializeWasm() must be awaited first!");
5613 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
5614 return nativeResponseValue;
5616 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
5618 export function C2Tuple_u32TxOutZ_get_b(owner: bigint): bigint {
5619 if(!isWasmInitialized) {
5620 throw new Error("initializeWasm() must be awaited first!");
5622 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
5623 return nativeResponseValue;
5625 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
5627 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(owner: bigint): number {
5628 if(!isWasmInitialized) {
5629 throw new Error("initializeWasm() must be awaited first!");
5631 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
5632 return nativeResponseValue;
5634 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
5636 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(owner: bigint): number {
5637 if(!isWasmInitialized) {
5638 throw new Error("initializeWasm() must be awaited first!");
5640 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
5641 return nativeResponseValue;
5644 export class LDKBalance {
5645 protected constructor() {}
5648 export function LDKBalance_ty_from_ptr(ptr: bigint): number {
5649 if(!isWasmInitialized) {
5650 throw new Error("initializeWasm() must be awaited first!");
5652 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
5653 return nativeResponseValue;
5656 export function LDKBalance_ClaimableOnChannelClose_get_amount_satoshis(ptr: bigint): bigint {
5657 if(!isWasmInitialized) {
5658 throw new Error("initializeWasm() must be awaited first!");
5660 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_amount_satoshis(ptr);
5661 return nativeResponseValue;
5664 export function LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis(ptr: bigint): bigint {
5665 if(!isWasmInitialized) {
5666 throw new Error("initializeWasm() must be awaited first!");
5668 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis(ptr);
5669 return nativeResponseValue;
5672 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: bigint): number {
5673 if(!isWasmInitialized) {
5674 throw new Error("initializeWasm() must be awaited first!");
5676 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
5677 return nativeResponseValue;
5680 export function LDKBalance_ContentiousClaimable_get_amount_satoshis(ptr: bigint): bigint {
5681 if(!isWasmInitialized) {
5682 throw new Error("initializeWasm() must be awaited first!");
5684 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_amount_satoshis(ptr);
5685 return nativeResponseValue;
5688 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: bigint): number {
5689 if(!isWasmInitialized) {
5690 throw new Error("initializeWasm() must be awaited first!");
5692 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
5693 return nativeResponseValue;
5696 export function LDKBalance_ContentiousClaimable_get_payment_hash(ptr: bigint): number {
5697 if(!isWasmInitialized) {
5698 throw new Error("initializeWasm() must be awaited first!");
5700 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_payment_hash(ptr);
5701 return nativeResponseValue;
5704 export function LDKBalance_ContentiousClaimable_get_payment_preimage(ptr: bigint): number {
5705 if(!isWasmInitialized) {
5706 throw new Error("initializeWasm() must be awaited first!");
5708 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_payment_preimage(ptr);
5709 return nativeResponseValue;
5712 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis(ptr: bigint): bigint {
5713 if(!isWasmInitialized) {
5714 throw new Error("initializeWasm() must be awaited first!");
5716 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis(ptr);
5717 return nativeResponseValue;
5720 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr: bigint): number {
5721 if(!isWasmInitialized) {
5722 throw new Error("initializeWasm() must be awaited first!");
5724 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(ptr);
5725 return nativeResponseValue;
5728 export function LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash(ptr: bigint): number {
5729 if(!isWasmInitialized) {
5730 throw new Error("initializeWasm() must be awaited first!");
5732 const nativeResponseValue = wasm.TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash(ptr);
5733 return nativeResponseValue;
5736 export function LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis(ptr: bigint): bigint {
5737 if(!isWasmInitialized) {
5738 throw new Error("initializeWasm() must be awaited first!");
5740 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis(ptr);
5741 return nativeResponseValue;
5744 export function LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr: bigint): number {
5745 if(!isWasmInitialized) {
5746 throw new Error("initializeWasm() must be awaited first!");
5748 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(ptr);
5749 return nativeResponseValue;
5752 export function LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash(ptr: bigint): number {
5753 if(!isWasmInitialized) {
5754 throw new Error("initializeWasm() must be awaited first!");
5756 const nativeResponseValue = wasm.TS_LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash(ptr);
5757 return nativeResponseValue;
5760 export function LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis(ptr: bigint): bigint {
5761 if(!isWasmInitialized) {
5762 throw new Error("initializeWasm() must be awaited first!");
5764 const nativeResponseValue = wasm.TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis(ptr);
5765 return nativeResponseValue;
5767 // struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR owner);
5769 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(owner: bigint): number {
5770 if(!isWasmInitialized) {
5771 throw new Error("initializeWasm() must be awaited first!");
5773 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(owner);
5774 return nativeResponseValue;
5776 // struct LDKChannelMonitor C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR owner);
5778 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(owner: bigint): bigint {
5779 if(!isWasmInitialized) {
5780 throw new Error("initializeWasm() must be awaited first!");
5782 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(owner);
5783 return nativeResponseValue;
5785 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5787 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(owner: bigint): bigint {
5788 if(!isWasmInitialized) {
5789 throw new Error("initializeWasm() must be awaited first!");
5791 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(owner);
5792 return nativeResponseValue;
5794 // struct LDKDecodeError CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
5796 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(owner: bigint): bigint {
5797 if(!isWasmInitialized) {
5798 throw new Error("initializeWasm() must be awaited first!");
5800 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(owner);
5801 return nativeResponseValue;
5804 export interface LDKType {
5806 debug_str (): number;
5811 export function LDKType_new(impl: LDKType): [bigint, number] {
5812 if(!isWasmInitialized) {
5813 throw new Error("initializeWasm() must be awaited first!");
5815 var new_obj_idx = js_objs.length;
5816 for (var i = 0; i < js_objs.length; i++) {
5817 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5819 js_objs[i] = new WeakRef(impl);
5820 return [wasm.TS_LDKType_new(i), i];
5822 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
5824 export function Type_type_id(this_arg: bigint): number {
5825 if(!isWasmInitialized) {
5826 throw new Error("initializeWasm() must be awaited first!");
5828 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
5829 return nativeResponseValue;
5831 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
5833 export function Type_debug_str(this_arg: bigint): number {
5834 if(!isWasmInitialized) {
5835 throw new Error("initializeWasm() must be awaited first!");
5837 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
5838 return nativeResponseValue;
5840 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
5842 export function Type_write(this_arg: bigint): number {
5843 if(!isWasmInitialized) {
5844 throw new Error("initializeWasm() must be awaited first!");
5846 const nativeResponseValue = wasm.TS_Type_write(this_arg);
5847 return nativeResponseValue;
5849 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5851 export function C2Tuple_PublicKeyTypeZ_get_a(owner: bigint): number {
5852 if(!isWasmInitialized) {
5853 throw new Error("initializeWasm() must be awaited first!");
5855 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
5856 return nativeResponseValue;
5858 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
5860 export function C2Tuple_PublicKeyTypeZ_get_b(owner: bigint): bigint {
5861 if(!isWasmInitialized) {
5862 throw new Error("initializeWasm() must be awaited first!");
5864 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
5865 return nativeResponseValue;
5867 // struct LDKPublicKey C2Tuple_PublicKeyCVec_SocketAddressZZ_get_a(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ *NONNULL_PTR owner);
5869 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_get_a(owner: bigint): number {
5870 if(!isWasmInitialized) {
5871 throw new Error("initializeWasm() must be awaited first!");
5873 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_get_a(owner);
5874 return nativeResponseValue;
5876 // struct LDKCVec_SocketAddressZ C2Tuple_PublicKeyCVec_SocketAddressZZ_get_b(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ *NONNULL_PTR owner);
5878 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_get_b(owner: bigint): number {
5879 if(!isWasmInitialized) {
5880 throw new Error("initializeWasm() must be awaited first!");
5882 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_get_b(owner);
5883 return nativeResponseValue;
5886 export interface LDKOnionMessageContents {
5887 tlv_type (): bigint;
5889 debug_str (): number;
5893 export function LDKOnionMessageContents_new(impl: LDKOnionMessageContents): [bigint, number] {
5894 if(!isWasmInitialized) {
5895 throw new Error("initializeWasm() must be awaited first!");
5897 var new_obj_idx = js_objs.length;
5898 for (var i = 0; i < js_objs.length; i++) {
5899 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5901 js_objs[i] = new WeakRef(impl);
5902 return [wasm.TS_LDKOnionMessageContents_new(i), i];
5904 // uint64_t OnionMessageContents_tlv_type LDKOnionMessageContents *NONNULL_PTR this_arg
5906 export function OnionMessageContents_tlv_type(this_arg: bigint): bigint {
5907 if(!isWasmInitialized) {
5908 throw new Error("initializeWasm() must be awaited first!");
5910 const nativeResponseValue = wasm.TS_OnionMessageContents_tlv_type(this_arg);
5911 return nativeResponseValue;
5913 // LDKCVec_u8Z OnionMessageContents_write LDKOnionMessageContents *NONNULL_PTR this_arg
5915 export function OnionMessageContents_write(this_arg: bigint): number {
5916 if(!isWasmInitialized) {
5917 throw new Error("initializeWasm() must be awaited first!");
5919 const nativeResponseValue = wasm.TS_OnionMessageContents_write(this_arg);
5920 return nativeResponseValue;
5922 // LDKStr OnionMessageContents_debug_str LDKOnionMessageContents *NONNULL_PTR this_arg
5924 export function OnionMessageContents_debug_str(this_arg: bigint): number {
5925 if(!isWasmInitialized) {
5926 throw new Error("initializeWasm() must be awaited first!");
5928 const nativeResponseValue = wasm.TS_OnionMessageContents_debug_str(this_arg);
5929 return nativeResponseValue;
5932 export class LDKCOption_OnionMessageContentsZ {
5933 protected constructor() {}
5936 export function LDKCOption_OnionMessageContentsZ_ty_from_ptr(ptr: bigint): number {
5937 if(!isWasmInitialized) {
5938 throw new Error("initializeWasm() must be awaited first!");
5940 const nativeResponseValue = wasm.TS_LDKCOption_OnionMessageContentsZ_ty_from_ptr(ptr);
5941 return nativeResponseValue;
5944 export function LDKCOption_OnionMessageContentsZ_Some_get_some(ptr: bigint): bigint {
5945 if(!isWasmInitialized) {
5946 throw new Error("initializeWasm() must be awaited first!");
5948 const nativeResponseValue = wasm.TS_LDKCOption_OnionMessageContentsZ_Some_get_some(ptr);
5949 return nativeResponseValue;
5951 // struct LDKCOption_OnionMessageContentsZ CResult_COption_OnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5953 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_get_ok(owner: bigint): bigint {
5954 if(!isWasmInitialized) {
5955 throw new Error("initializeWasm() must be awaited first!");
5957 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_get_ok(owner);
5958 return nativeResponseValue;
5960 // struct LDKDecodeError CResult_COption_OnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner);
5962 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_get_err(owner: bigint): bigint {
5963 if(!isWasmInitialized) {
5964 throw new Error("initializeWasm() must be awaited first!");
5966 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_get_err(owner);
5967 return nativeResponseValue;
5969 // struct LDKOnionMessageContents C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_a(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR owner);
5971 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_a(owner: bigint): bigint {
5972 if(!isWasmInitialized) {
5973 throw new Error("initializeWasm() must be awaited first!");
5975 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_a(owner);
5976 return nativeResponseValue;
5978 // struct LDKDestination C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_b(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR owner);
5980 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_b(owner: bigint): bigint {
5981 if(!isWasmInitialized) {
5982 throw new Error("initializeWasm() must be awaited first!");
5984 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_b(owner);
5985 return nativeResponseValue;
5987 // struct LDKBlindedPath C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_c(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR owner);
5989 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_c(owner: bigint): bigint {
5990 if(!isWasmInitialized) {
5991 throw new Error("initializeWasm() must be awaited first!");
5993 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_get_c(owner);
5994 return nativeResponseValue;
5997 export class LDKCOption_TypeZ {
5998 protected constructor() {}
6001 export function LDKCOption_TypeZ_ty_from_ptr(ptr: bigint): number {
6002 if(!isWasmInitialized) {
6003 throw new Error("initializeWasm() must be awaited first!");
6005 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
6006 return nativeResponseValue;
6009 export function LDKCOption_TypeZ_Some_get_some(ptr: bigint): bigint {
6010 if(!isWasmInitialized) {
6011 throw new Error("initializeWasm() must be awaited first!");
6013 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
6014 return nativeResponseValue;
6016 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
6018 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: bigint): bigint {
6019 if(!isWasmInitialized) {
6020 throw new Error("initializeWasm() must be awaited first!");
6022 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
6023 return nativeResponseValue;
6025 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
6027 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: bigint): bigint {
6028 if(!isWasmInitialized) {
6029 throw new Error("initializeWasm() must be awaited first!");
6031 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
6032 return nativeResponseValue;
6035 export class LDKCOption_SocketAddressZ {
6036 protected constructor() {}
6039 export function LDKCOption_SocketAddressZ_ty_from_ptr(ptr: bigint): number {
6040 if(!isWasmInitialized) {
6041 throw new Error("initializeWasm() must be awaited first!");
6043 const nativeResponseValue = wasm.TS_LDKCOption_SocketAddressZ_ty_from_ptr(ptr);
6044 return nativeResponseValue;
6047 export function LDKCOption_SocketAddressZ_Some_get_some(ptr: bigint): bigint {
6048 if(!isWasmInitialized) {
6049 throw new Error("initializeWasm() must be awaited first!");
6051 const nativeResponseValue = wasm.TS_LDKCOption_SocketAddressZ_Some_get_some(ptr);
6052 return nativeResponseValue;
6054 // struct LDKPublicKey C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR owner);
6056 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(owner: bigint): number {
6057 if(!isWasmInitialized) {
6058 throw new Error("initializeWasm() must be awaited first!");
6060 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(owner);
6061 return nativeResponseValue;
6063 // struct LDKCOption_SocketAddressZ C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR owner);
6065 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(owner: bigint): bigint {
6066 if(!isWasmInitialized) {
6067 throw new Error("initializeWasm() must be awaited first!");
6069 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(owner);
6070 return nativeResponseValue;
6072 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
6074 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: bigint): number {
6075 if(!isWasmInitialized) {
6076 throw new Error("initializeWasm() must be awaited first!");
6078 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
6079 return nativeResponseValue;
6081 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
6083 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: bigint): bigint {
6084 if(!isWasmInitialized) {
6085 throw new Error("initializeWasm() must be awaited first!");
6087 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
6088 return nativeResponseValue;
6090 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
6092 export function CResult_NonePeerHandleErrorZ_get_ok(owner: bigint): void {
6093 if(!isWasmInitialized) {
6094 throw new Error("initializeWasm() must be awaited first!");
6096 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
6097 // debug statements here
6099 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
6101 export function CResult_NonePeerHandleErrorZ_get_err(owner: bigint): bigint {
6102 if(!isWasmInitialized) {
6103 throw new Error("initializeWasm() must be awaited first!");
6105 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
6106 return nativeResponseValue;
6108 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
6110 export function CResult_boolPeerHandleErrorZ_get_ok(owner: bigint): boolean {
6111 if(!isWasmInitialized) {
6112 throw new Error("initializeWasm() must be awaited first!");
6114 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
6115 return nativeResponseValue;
6117 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
6119 export function CResult_boolPeerHandleErrorZ_get_err(owner: bigint): bigint {
6120 if(!isWasmInitialized) {
6121 throw new Error("initializeWasm() must be awaited first!");
6123 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
6124 return nativeResponseValue;
6127 export class LDKGraphSyncError {
6128 protected constructor() {}
6131 export function LDKGraphSyncError_ty_from_ptr(ptr: bigint): number {
6132 if(!isWasmInitialized) {
6133 throw new Error("initializeWasm() must be awaited first!");
6135 const nativeResponseValue = wasm.TS_LDKGraphSyncError_ty_from_ptr(ptr);
6136 return nativeResponseValue;
6139 export function LDKGraphSyncError_DecodeError_get_decode_error(ptr: bigint): bigint {
6140 if(!isWasmInitialized) {
6141 throw new Error("initializeWasm() must be awaited first!");
6143 const nativeResponseValue = wasm.TS_LDKGraphSyncError_DecodeError_get_decode_error(ptr);
6144 return nativeResponseValue;
6147 export function LDKGraphSyncError_LightningError_get_lightning_error(ptr: bigint): bigint {
6148 if(!isWasmInitialized) {
6149 throw new Error("initializeWasm() must be awaited first!");
6151 const nativeResponseValue = wasm.TS_LDKGraphSyncError_LightningError_get_lightning_error(ptr);
6152 return nativeResponseValue;
6154 // uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
6156 export function CResult_u32GraphSyncErrorZ_get_ok(owner: bigint): number {
6157 if(!isWasmInitialized) {
6158 throw new Error("initializeWasm() must be awaited first!");
6160 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_ok(owner);
6161 return nativeResponseValue;
6163 // struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner);
6165 export function CResult_u32GraphSyncErrorZ_get_err(owner: bigint): bigint {
6166 if(!isWasmInitialized) {
6167 throw new Error("initializeWasm() must be awaited first!");
6169 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_get_err(owner);
6170 return nativeResponseValue;
6172 // struct LDKCVec_u8Z CResult_CVec_u8ZIOErrorZ_get_ok(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR owner);
6174 export function CResult_CVec_u8ZIOErrorZ_get_ok(owner: bigint): number {
6175 if(!isWasmInitialized) {
6176 throw new Error("initializeWasm() must be awaited first!");
6178 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_get_ok(owner);
6179 return nativeResponseValue;
6181 // enum LDKIOError CResult_CVec_u8ZIOErrorZ_get_err(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR owner);
6183 export function CResult_CVec_u8ZIOErrorZ_get_err(owner: bigint): IOError {
6184 if(!isWasmInitialized) {
6185 throw new Error("initializeWasm() must be awaited first!");
6187 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_get_err(owner);
6188 return nativeResponseValue;
6190 // void CResult_NoneIOErrorZ_get_ok(LDKCResult_NoneIOErrorZ *NONNULL_PTR owner);
6192 export function CResult_NoneIOErrorZ_get_ok(owner: bigint): void {
6193 if(!isWasmInitialized) {
6194 throw new Error("initializeWasm() must be awaited first!");
6196 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_get_ok(owner);
6197 // debug statements here
6199 // enum LDKIOError CResult_NoneIOErrorZ_get_err(LDKCResult_NoneIOErrorZ *NONNULL_PTR owner);
6201 export function CResult_NoneIOErrorZ_get_err(owner: bigint): IOError {
6202 if(!isWasmInitialized) {
6203 throw new Error("initializeWasm() must be awaited first!");
6205 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_get_err(owner);
6206 return nativeResponseValue;
6208 // struct LDKCVec_StrZ CResult_CVec_StrZIOErrorZ_get_ok(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR owner);
6210 export function CResult_CVec_StrZIOErrorZ_get_ok(owner: bigint): number {
6211 if(!isWasmInitialized) {
6212 throw new Error("initializeWasm() must be awaited first!");
6214 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_get_ok(owner);
6215 return nativeResponseValue;
6217 // enum LDKIOError CResult_CVec_StrZIOErrorZ_get_err(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR owner);
6219 export function CResult_CVec_StrZIOErrorZ_get_err(owner: bigint): IOError {
6220 if(!isWasmInitialized) {
6221 throw new Error("initializeWasm() must be awaited first!");
6223 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_get_err(owner);
6224 return nativeResponseValue;
6226 // struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR owner);
6228 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(owner: bigint): number {
6229 if(!isWasmInitialized) {
6230 throw new Error("initializeWasm() must be awaited first!");
6232 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(owner);
6233 return nativeResponseValue;
6235 // enum LDKIOError CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR owner);
6237 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(owner: bigint): IOError {
6238 if(!isWasmInitialized) {
6239 throw new Error("initializeWasm() must be awaited first!");
6241 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(owner);
6242 return nativeResponseValue;
6244 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR owner);
6246 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(owner: bigint): bigint {
6247 if(!isWasmInitialized) {
6248 throw new Error("initializeWasm() must be awaited first!");
6250 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(owner);
6251 return nativeResponseValue;
6253 // enum LDKIOError CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR owner);
6255 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(owner: bigint): IOError {
6256 if(!isWasmInitialized) {
6257 throw new Error("initializeWasm() must be awaited first!");
6259 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(owner);
6260 return nativeResponseValue;
6263 export class LDKCOption_SecretKeyZ {
6264 protected constructor() {}
6267 export function LDKCOption_SecretKeyZ_ty_from_ptr(ptr: bigint): number {
6268 if(!isWasmInitialized) {
6269 throw new Error("initializeWasm() must be awaited first!");
6271 const nativeResponseValue = wasm.TS_LDKCOption_SecretKeyZ_ty_from_ptr(ptr);
6272 return nativeResponseValue;
6275 export function LDKCOption_SecretKeyZ_Some_get_some(ptr: bigint): number {
6276 if(!isWasmInitialized) {
6277 throw new Error("initializeWasm() must be awaited first!");
6279 const nativeResponseValue = wasm.TS_LDKCOption_SecretKeyZ_Some_get_some(ptr);
6280 return nativeResponseValue;
6282 // struct LDKVerifiedInvoiceRequest CResult_VerifiedInvoiceRequestNoneZ_get_ok(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR owner);
6284 export function CResult_VerifiedInvoiceRequestNoneZ_get_ok(owner: bigint): bigint {
6285 if(!isWasmInitialized) {
6286 throw new Error("initializeWasm() must be awaited first!");
6288 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_get_ok(owner);
6289 return nativeResponseValue;
6291 // void CResult_VerifiedInvoiceRequestNoneZ_get_err(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR owner);
6293 export function CResult_VerifiedInvoiceRequestNoneZ_get_err(owner: bigint): void {
6294 if(!isWasmInitialized) {
6295 throw new Error("initializeWasm() must be awaited first!");
6297 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_get_err(owner);
6298 // debug statements here
6301 export class LDKCOption_i64Z {
6302 protected constructor() {}
6305 export function LDKCOption_i64Z_ty_from_ptr(ptr: bigint): number {
6306 if(!isWasmInitialized) {
6307 throw new Error("initializeWasm() must be awaited first!");
6309 const nativeResponseValue = wasm.TS_LDKCOption_i64Z_ty_from_ptr(ptr);
6310 return nativeResponseValue;
6313 export function LDKCOption_i64Z_Some_get_some(ptr: bigint): bigint {
6314 if(!isWasmInitialized) {
6315 throw new Error("initializeWasm() must be awaited first!");
6317 const nativeResponseValue = wasm.TS_LDKCOption_i64Z_Some_get_some(ptr);
6318 return nativeResponseValue;
6320 // struct LDKSocketAddress CResult_SocketAddressDecodeErrorZ_get_ok(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR owner);
6322 export function CResult_SocketAddressDecodeErrorZ_get_ok(owner: bigint): bigint {
6323 if(!isWasmInitialized) {
6324 throw new Error("initializeWasm() must be awaited first!");
6326 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_get_ok(owner);
6327 return nativeResponseValue;
6329 // struct LDKDecodeError CResult_SocketAddressDecodeErrorZ_get_err(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR owner);
6331 export function CResult_SocketAddressDecodeErrorZ_get_err(owner: bigint): bigint {
6332 if(!isWasmInitialized) {
6333 throw new Error("initializeWasm() must be awaited first!");
6335 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_get_err(owner);
6336 return nativeResponseValue;
6338 // struct LDKSocketAddress CResult_SocketAddressSocketAddressParseErrorZ_get_ok(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR owner);
6340 export function CResult_SocketAddressSocketAddressParseErrorZ_get_ok(owner: bigint): bigint {
6341 if(!isWasmInitialized) {
6342 throw new Error("initializeWasm() must be awaited first!");
6344 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_get_ok(owner);
6345 return nativeResponseValue;
6347 // enum LDKSocketAddressParseError CResult_SocketAddressSocketAddressParseErrorZ_get_err(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR owner);
6349 export function CResult_SocketAddressSocketAddressParseErrorZ_get_err(owner: bigint): SocketAddressParseError {
6350 if(!isWasmInitialized) {
6351 throw new Error("initializeWasm() must be awaited first!");
6353 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_get_err(owner);
6354 return nativeResponseValue;
6356 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
6358 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
6359 if(!isWasmInitialized) {
6360 throw new Error("initializeWasm() must be awaited first!");
6362 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
6363 return nativeResponseValue;
6365 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
6367 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: bigint): bigint {
6368 if(!isWasmInitialized) {
6369 throw new Error("initializeWasm() must be awaited first!");
6371 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
6372 return nativeResponseValue;
6374 // struct LDKAcceptChannelV2 CResult_AcceptChannelV2DecodeErrorZ_get_ok(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner);
6376 export function CResult_AcceptChannelV2DecodeErrorZ_get_ok(owner: bigint): bigint {
6377 if(!isWasmInitialized) {
6378 throw new Error("initializeWasm() must be awaited first!");
6380 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_get_ok(owner);
6381 return nativeResponseValue;
6383 // struct LDKDecodeError CResult_AcceptChannelV2DecodeErrorZ_get_err(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner);
6385 export function CResult_AcceptChannelV2DecodeErrorZ_get_err(owner: bigint): bigint {
6386 if(!isWasmInitialized) {
6387 throw new Error("initializeWasm() must be awaited first!");
6389 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_get_err(owner);
6390 return nativeResponseValue;
6392 // struct LDKStfu CResult_StfuDecodeErrorZ_get_ok(LDKCResult_StfuDecodeErrorZ *NONNULL_PTR owner);
6394 export function CResult_StfuDecodeErrorZ_get_ok(owner: bigint): bigint {
6395 if(!isWasmInitialized) {
6396 throw new Error("initializeWasm() must be awaited first!");
6398 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_get_ok(owner);
6399 return nativeResponseValue;
6401 // struct LDKDecodeError CResult_StfuDecodeErrorZ_get_err(LDKCResult_StfuDecodeErrorZ *NONNULL_PTR owner);
6403 export function CResult_StfuDecodeErrorZ_get_err(owner: bigint): bigint {
6404 if(!isWasmInitialized) {
6405 throw new Error("initializeWasm() must be awaited first!");
6407 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_get_err(owner);
6408 return nativeResponseValue;
6410 // struct LDKSplice CResult_SpliceDecodeErrorZ_get_ok(LDKCResult_SpliceDecodeErrorZ *NONNULL_PTR owner);
6412 export function CResult_SpliceDecodeErrorZ_get_ok(owner: bigint): bigint {
6413 if(!isWasmInitialized) {
6414 throw new Error("initializeWasm() must be awaited first!");
6416 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_get_ok(owner);
6417 return nativeResponseValue;
6419 // struct LDKDecodeError CResult_SpliceDecodeErrorZ_get_err(LDKCResult_SpliceDecodeErrorZ *NONNULL_PTR owner);
6421 export function CResult_SpliceDecodeErrorZ_get_err(owner: bigint): bigint {
6422 if(!isWasmInitialized) {
6423 throw new Error("initializeWasm() must be awaited first!");
6425 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_get_err(owner);
6426 return nativeResponseValue;
6428 // struct LDKSpliceAck CResult_SpliceAckDecodeErrorZ_get_ok(LDKCResult_SpliceAckDecodeErrorZ *NONNULL_PTR owner);
6430 export function CResult_SpliceAckDecodeErrorZ_get_ok(owner: bigint): bigint {
6431 if(!isWasmInitialized) {
6432 throw new Error("initializeWasm() must be awaited first!");
6434 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_get_ok(owner);
6435 return nativeResponseValue;
6437 // struct LDKDecodeError CResult_SpliceAckDecodeErrorZ_get_err(LDKCResult_SpliceAckDecodeErrorZ *NONNULL_PTR owner);
6439 export function CResult_SpliceAckDecodeErrorZ_get_err(owner: bigint): bigint {
6440 if(!isWasmInitialized) {
6441 throw new Error("initializeWasm() must be awaited first!");
6443 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_get_err(owner);
6444 return nativeResponseValue;
6446 // struct LDKSpliceLocked CResult_SpliceLockedDecodeErrorZ_get_ok(LDKCResult_SpliceLockedDecodeErrorZ *NONNULL_PTR owner);
6448 export function CResult_SpliceLockedDecodeErrorZ_get_ok(owner: bigint): bigint {
6449 if(!isWasmInitialized) {
6450 throw new Error("initializeWasm() must be awaited first!");
6452 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_get_ok(owner);
6453 return nativeResponseValue;
6455 // struct LDKDecodeError CResult_SpliceLockedDecodeErrorZ_get_err(LDKCResult_SpliceLockedDecodeErrorZ *NONNULL_PTR owner);
6457 export function CResult_SpliceLockedDecodeErrorZ_get_err(owner: bigint): bigint {
6458 if(!isWasmInitialized) {
6459 throw new Error("initializeWasm() must be awaited first!");
6461 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_get_err(owner);
6462 return nativeResponseValue;
6464 // struct LDKTxAddInput CResult_TxAddInputDecodeErrorZ_get_ok(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner);
6466 export function CResult_TxAddInputDecodeErrorZ_get_ok(owner: bigint): bigint {
6467 if(!isWasmInitialized) {
6468 throw new Error("initializeWasm() must be awaited first!");
6470 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_get_ok(owner);
6471 return nativeResponseValue;
6473 // struct LDKDecodeError CResult_TxAddInputDecodeErrorZ_get_err(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner);
6475 export function CResult_TxAddInputDecodeErrorZ_get_err(owner: bigint): bigint {
6476 if(!isWasmInitialized) {
6477 throw new Error("initializeWasm() must be awaited first!");
6479 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_get_err(owner);
6480 return nativeResponseValue;
6482 // struct LDKTxAddOutput CResult_TxAddOutputDecodeErrorZ_get_ok(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner);
6484 export function CResult_TxAddOutputDecodeErrorZ_get_ok(owner: bigint): bigint {
6485 if(!isWasmInitialized) {
6486 throw new Error("initializeWasm() must be awaited first!");
6488 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_get_ok(owner);
6489 return nativeResponseValue;
6491 // struct LDKDecodeError CResult_TxAddOutputDecodeErrorZ_get_err(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner);
6493 export function CResult_TxAddOutputDecodeErrorZ_get_err(owner: bigint): bigint {
6494 if(!isWasmInitialized) {
6495 throw new Error("initializeWasm() must be awaited first!");
6497 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_get_err(owner);
6498 return nativeResponseValue;
6500 // struct LDKTxRemoveInput CResult_TxRemoveInputDecodeErrorZ_get_ok(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner);
6502 export function CResult_TxRemoveInputDecodeErrorZ_get_ok(owner: bigint): bigint {
6503 if(!isWasmInitialized) {
6504 throw new Error("initializeWasm() must be awaited first!");
6506 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_get_ok(owner);
6507 return nativeResponseValue;
6509 // struct LDKDecodeError CResult_TxRemoveInputDecodeErrorZ_get_err(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner);
6511 export function CResult_TxRemoveInputDecodeErrorZ_get_err(owner: bigint): bigint {
6512 if(!isWasmInitialized) {
6513 throw new Error("initializeWasm() must be awaited first!");
6515 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_get_err(owner);
6516 return nativeResponseValue;
6518 // struct LDKTxRemoveOutput CResult_TxRemoveOutputDecodeErrorZ_get_ok(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner);
6520 export function CResult_TxRemoveOutputDecodeErrorZ_get_ok(owner: bigint): bigint {
6521 if(!isWasmInitialized) {
6522 throw new Error("initializeWasm() must be awaited first!");
6524 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_get_ok(owner);
6525 return nativeResponseValue;
6527 // struct LDKDecodeError CResult_TxRemoveOutputDecodeErrorZ_get_err(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner);
6529 export function CResult_TxRemoveOutputDecodeErrorZ_get_err(owner: bigint): bigint {
6530 if(!isWasmInitialized) {
6531 throw new Error("initializeWasm() must be awaited first!");
6533 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_get_err(owner);
6534 return nativeResponseValue;
6536 // struct LDKTxComplete CResult_TxCompleteDecodeErrorZ_get_ok(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner);
6538 export function CResult_TxCompleteDecodeErrorZ_get_ok(owner: bigint): bigint {
6539 if(!isWasmInitialized) {
6540 throw new Error("initializeWasm() must be awaited first!");
6542 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_get_ok(owner);
6543 return nativeResponseValue;
6545 // struct LDKDecodeError CResult_TxCompleteDecodeErrorZ_get_err(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner);
6547 export function CResult_TxCompleteDecodeErrorZ_get_err(owner: bigint): bigint {
6548 if(!isWasmInitialized) {
6549 throw new Error("initializeWasm() must be awaited first!");
6551 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_get_err(owner);
6552 return nativeResponseValue;
6554 // struct LDKTxSignatures CResult_TxSignaturesDecodeErrorZ_get_ok(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner);
6556 export function CResult_TxSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
6557 if(!isWasmInitialized) {
6558 throw new Error("initializeWasm() must be awaited first!");
6560 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_get_ok(owner);
6561 return nativeResponseValue;
6563 // struct LDKDecodeError CResult_TxSignaturesDecodeErrorZ_get_err(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner);
6565 export function CResult_TxSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
6566 if(!isWasmInitialized) {
6567 throw new Error("initializeWasm() must be awaited first!");
6569 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_get_err(owner);
6570 return nativeResponseValue;
6572 // struct LDKTxInitRbf CResult_TxInitRbfDecodeErrorZ_get_ok(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner);
6574 export function CResult_TxInitRbfDecodeErrorZ_get_ok(owner: bigint): bigint {
6575 if(!isWasmInitialized) {
6576 throw new Error("initializeWasm() must be awaited first!");
6578 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_get_ok(owner);
6579 return nativeResponseValue;
6581 // struct LDKDecodeError CResult_TxInitRbfDecodeErrorZ_get_err(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner);
6583 export function CResult_TxInitRbfDecodeErrorZ_get_err(owner: bigint): bigint {
6584 if(!isWasmInitialized) {
6585 throw new Error("initializeWasm() must be awaited first!");
6587 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_get_err(owner);
6588 return nativeResponseValue;
6590 // struct LDKTxAckRbf CResult_TxAckRbfDecodeErrorZ_get_ok(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner);
6592 export function CResult_TxAckRbfDecodeErrorZ_get_ok(owner: bigint): bigint {
6593 if(!isWasmInitialized) {
6594 throw new Error("initializeWasm() must be awaited first!");
6596 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_get_ok(owner);
6597 return nativeResponseValue;
6599 // struct LDKDecodeError CResult_TxAckRbfDecodeErrorZ_get_err(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner);
6601 export function CResult_TxAckRbfDecodeErrorZ_get_err(owner: bigint): bigint {
6602 if(!isWasmInitialized) {
6603 throw new Error("initializeWasm() must be awaited first!");
6605 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_get_err(owner);
6606 return nativeResponseValue;
6608 // struct LDKTxAbort CResult_TxAbortDecodeErrorZ_get_ok(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner);
6610 export function CResult_TxAbortDecodeErrorZ_get_ok(owner: bigint): bigint {
6611 if(!isWasmInitialized) {
6612 throw new Error("initializeWasm() must be awaited first!");
6614 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_get_ok(owner);
6615 return nativeResponseValue;
6617 // struct LDKDecodeError CResult_TxAbortDecodeErrorZ_get_err(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner);
6619 export function CResult_TxAbortDecodeErrorZ_get_err(owner: bigint): bigint {
6620 if(!isWasmInitialized) {
6621 throw new Error("initializeWasm() must be awaited first!");
6623 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_get_err(owner);
6624 return nativeResponseValue;
6626 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
6628 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: bigint): bigint {
6629 if(!isWasmInitialized) {
6630 throw new Error("initializeWasm() must be awaited first!");
6632 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
6633 return nativeResponseValue;
6635 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
6637 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: bigint): bigint {
6638 if(!isWasmInitialized) {
6639 throw new Error("initializeWasm() must be awaited first!");
6641 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
6642 return nativeResponseValue;
6644 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
6646 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: bigint): bigint {
6647 if(!isWasmInitialized) {
6648 throw new Error("initializeWasm() must be awaited first!");
6650 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
6651 return nativeResponseValue;
6653 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
6655 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: bigint): bigint {
6656 if(!isWasmInitialized) {
6657 throw new Error("initializeWasm() must be awaited first!");
6659 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
6660 return nativeResponseValue;
6662 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
6664 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6665 if(!isWasmInitialized) {
6666 throw new Error("initializeWasm() must be awaited first!");
6668 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
6669 return nativeResponseValue;
6671 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
6673 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6674 if(!isWasmInitialized) {
6675 throw new Error("initializeWasm() must be awaited first!");
6677 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
6678 return nativeResponseValue;
6680 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
6682 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
6683 if(!isWasmInitialized) {
6684 throw new Error("initializeWasm() must be awaited first!");
6686 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
6687 return nativeResponseValue;
6689 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
6691 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: bigint): bigint {
6692 if(!isWasmInitialized) {
6693 throw new Error("initializeWasm() must be awaited first!");
6695 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
6696 return nativeResponseValue;
6698 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
6700 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6701 if(!isWasmInitialized) {
6702 throw new Error("initializeWasm() must be awaited first!");
6704 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
6705 return nativeResponseValue;
6707 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
6709 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6710 if(!isWasmInitialized) {
6711 throw new Error("initializeWasm() must be awaited first!");
6713 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
6714 return nativeResponseValue;
6716 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
6718 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: bigint): bigint {
6719 if(!isWasmInitialized) {
6720 throw new Error("initializeWasm() must be awaited first!");
6722 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
6723 return nativeResponseValue;
6725 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
6727 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: bigint): bigint {
6728 if(!isWasmInitialized) {
6729 throw new Error("initializeWasm() must be awaited first!");
6731 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
6732 return nativeResponseValue;
6734 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
6736 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: bigint): bigint {
6737 if(!isWasmInitialized) {
6738 throw new Error("initializeWasm() must be awaited first!");
6740 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
6741 return nativeResponseValue;
6743 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
6745 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: bigint): bigint {
6746 if(!isWasmInitialized) {
6747 throw new Error("initializeWasm() must be awaited first!");
6749 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
6750 return nativeResponseValue;
6752 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
6754 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: bigint): bigint {
6755 if(!isWasmInitialized) {
6756 throw new Error("initializeWasm() must be awaited first!");
6758 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
6759 return nativeResponseValue;
6761 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
6763 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: bigint): bigint {
6764 if(!isWasmInitialized) {
6765 throw new Error("initializeWasm() must be awaited first!");
6767 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
6768 return nativeResponseValue;
6770 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
6772 export function CResult_InitDecodeErrorZ_get_ok(owner: bigint): bigint {
6773 if(!isWasmInitialized) {
6774 throw new Error("initializeWasm() must be awaited first!");
6776 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
6777 return nativeResponseValue;
6779 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
6781 export function CResult_InitDecodeErrorZ_get_err(owner: bigint): bigint {
6782 if(!isWasmInitialized) {
6783 throw new Error("initializeWasm() must be awaited first!");
6785 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
6786 return nativeResponseValue;
6788 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
6790 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: bigint): bigint {
6791 if(!isWasmInitialized) {
6792 throw new Error("initializeWasm() must be awaited first!");
6794 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
6795 return nativeResponseValue;
6797 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
6799 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: bigint): bigint {
6800 if(!isWasmInitialized) {
6801 throw new Error("initializeWasm() must be awaited first!");
6803 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
6804 return nativeResponseValue;
6806 // struct LDKOpenChannelV2 CResult_OpenChannelV2DecodeErrorZ_get_ok(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner);
6808 export function CResult_OpenChannelV2DecodeErrorZ_get_ok(owner: bigint): bigint {
6809 if(!isWasmInitialized) {
6810 throw new Error("initializeWasm() must be awaited first!");
6812 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_get_ok(owner);
6813 return nativeResponseValue;
6815 // struct LDKDecodeError CResult_OpenChannelV2DecodeErrorZ_get_err(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner);
6817 export function CResult_OpenChannelV2DecodeErrorZ_get_err(owner: bigint): bigint {
6818 if(!isWasmInitialized) {
6819 throw new Error("initializeWasm() must be awaited first!");
6821 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_get_err(owner);
6822 return nativeResponseValue;
6824 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
6826 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: bigint): bigint {
6827 if(!isWasmInitialized) {
6828 throw new Error("initializeWasm() must be awaited first!");
6830 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
6831 return nativeResponseValue;
6833 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
6835 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: bigint): bigint {
6836 if(!isWasmInitialized) {
6837 throw new Error("initializeWasm() must be awaited first!");
6839 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
6840 return nativeResponseValue;
6842 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
6844 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: bigint): bigint {
6845 if(!isWasmInitialized) {
6846 throw new Error("initializeWasm() must be awaited first!");
6848 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
6849 return nativeResponseValue;
6851 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
6853 export function CResult_ShutdownDecodeErrorZ_get_err(owner: bigint): bigint {
6854 if(!isWasmInitialized) {
6855 throw new Error("initializeWasm() must be awaited first!");
6857 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
6858 return nativeResponseValue;
6860 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
6862 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6863 if(!isWasmInitialized) {
6864 throw new Error("initializeWasm() must be awaited first!");
6866 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
6867 return nativeResponseValue;
6869 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
6871 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6872 if(!isWasmInitialized) {
6873 throw new Error("initializeWasm() must be awaited first!");
6875 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
6876 return nativeResponseValue;
6878 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
6880 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6881 if(!isWasmInitialized) {
6882 throw new Error("initializeWasm() must be awaited first!");
6884 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
6885 return nativeResponseValue;
6887 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
6889 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6890 if(!isWasmInitialized) {
6891 throw new Error("initializeWasm() must be awaited first!");
6893 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
6894 return nativeResponseValue;
6896 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
6898 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: bigint): bigint {
6899 if(!isWasmInitialized) {
6900 throw new Error("initializeWasm() must be awaited first!");
6902 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
6903 return nativeResponseValue;
6905 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
6907 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: bigint): bigint {
6908 if(!isWasmInitialized) {
6909 throw new Error("initializeWasm() must be awaited first!");
6911 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
6912 return nativeResponseValue;
6914 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
6916 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6917 if(!isWasmInitialized) {
6918 throw new Error("initializeWasm() must be awaited first!");
6920 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
6921 return nativeResponseValue;
6923 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
6925 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6926 if(!isWasmInitialized) {
6927 throw new Error("initializeWasm() must be awaited first!");
6929 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
6930 return nativeResponseValue;
6932 // struct LDKOnionPacket CResult_OnionPacketDecodeErrorZ_get_ok(LDKCResult_OnionPacketDecodeErrorZ *NONNULL_PTR owner);
6934 export function CResult_OnionPacketDecodeErrorZ_get_ok(owner: bigint): bigint {
6935 if(!isWasmInitialized) {
6936 throw new Error("initializeWasm() must be awaited first!");
6938 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_get_ok(owner);
6939 return nativeResponseValue;
6941 // struct LDKDecodeError CResult_OnionPacketDecodeErrorZ_get_err(LDKCResult_OnionPacketDecodeErrorZ *NONNULL_PTR owner);
6943 export function CResult_OnionPacketDecodeErrorZ_get_err(owner: bigint): bigint {
6944 if(!isWasmInitialized) {
6945 throw new Error("initializeWasm() must be awaited first!");
6947 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_get_err(owner);
6948 return nativeResponseValue;
6950 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
6952 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
6953 if(!isWasmInitialized) {
6954 throw new Error("initializeWasm() must be awaited first!");
6956 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
6957 return nativeResponseValue;
6959 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
6961 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
6962 if(!isWasmInitialized) {
6963 throw new Error("initializeWasm() must be awaited first!");
6965 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
6966 return nativeResponseValue;
6968 // struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
6970 export function CResult_OnionMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
6971 if(!isWasmInitialized) {
6972 throw new Error("initializeWasm() must be awaited first!");
6974 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_ok(owner);
6975 return nativeResponseValue;
6977 // struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner);
6979 export function CResult_OnionMessageDecodeErrorZ_get_err(owner: bigint): bigint {
6980 if(!isWasmInitialized) {
6981 throw new Error("initializeWasm() must be awaited first!");
6983 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_get_err(owner);
6984 return nativeResponseValue;
6986 // struct LDKFinalOnionHopData CResult_FinalOnionHopDataDecodeErrorZ_get_ok(LDKCResult_FinalOnionHopDataDecodeErrorZ *NONNULL_PTR owner);
6988 export function CResult_FinalOnionHopDataDecodeErrorZ_get_ok(owner: bigint): bigint {
6989 if(!isWasmInitialized) {
6990 throw new Error("initializeWasm() must be awaited first!");
6992 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_get_ok(owner);
6993 return nativeResponseValue;
6995 // struct LDKDecodeError CResult_FinalOnionHopDataDecodeErrorZ_get_err(LDKCResult_FinalOnionHopDataDecodeErrorZ *NONNULL_PTR owner);
6997 export function CResult_FinalOnionHopDataDecodeErrorZ_get_err(owner: bigint): bigint {
6998 if(!isWasmInitialized) {
6999 throw new Error("initializeWasm() must be awaited first!");
7001 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_get_err(owner);
7002 return nativeResponseValue;
7004 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
7006 export function CResult_PingDecodeErrorZ_get_ok(owner: bigint): bigint {
7007 if(!isWasmInitialized) {
7008 throw new Error("initializeWasm() must be awaited first!");
7010 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
7011 return nativeResponseValue;
7013 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
7015 export function CResult_PingDecodeErrorZ_get_err(owner: bigint): bigint {
7016 if(!isWasmInitialized) {
7017 throw new Error("initializeWasm() must be awaited first!");
7019 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
7020 return nativeResponseValue;
7022 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
7024 export function CResult_PongDecodeErrorZ_get_ok(owner: bigint): bigint {
7025 if(!isWasmInitialized) {
7026 throw new Error("initializeWasm() must be awaited first!");
7028 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
7029 return nativeResponseValue;
7031 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
7033 export function CResult_PongDecodeErrorZ_get_err(owner: bigint): bigint {
7034 if(!isWasmInitialized) {
7035 throw new Error("initializeWasm() must be awaited first!");
7037 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
7038 return nativeResponseValue;
7040 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7042 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7043 if(!isWasmInitialized) {
7044 throw new Error("initializeWasm() must be awaited first!");
7046 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
7047 return nativeResponseValue;
7049 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7051 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7052 if(!isWasmInitialized) {
7053 throw new Error("initializeWasm() must be awaited first!");
7055 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
7056 return nativeResponseValue;
7058 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7060 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7061 if(!isWasmInitialized) {
7062 throw new Error("initializeWasm() must be awaited first!");
7064 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
7065 return nativeResponseValue;
7067 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7069 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7070 if(!isWasmInitialized) {
7071 throw new Error("initializeWasm() must be awaited first!");
7073 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
7074 return nativeResponseValue;
7076 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7078 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
7079 if(!isWasmInitialized) {
7080 throw new Error("initializeWasm() must be awaited first!");
7082 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
7083 return nativeResponseValue;
7085 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7087 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
7088 if(!isWasmInitialized) {
7089 throw new Error("initializeWasm() must be awaited first!");
7091 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
7092 return nativeResponseValue;
7094 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7096 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: bigint): bigint {
7097 if(!isWasmInitialized) {
7098 throw new Error("initializeWasm() must be awaited first!");
7100 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
7101 return nativeResponseValue;
7103 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
7105 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: bigint): bigint {
7106 if(!isWasmInitialized) {
7107 throw new Error("initializeWasm() must be awaited first!");
7109 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
7110 return nativeResponseValue;
7112 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
7114 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
7115 if(!isWasmInitialized) {
7116 throw new Error("initializeWasm() must be awaited first!");
7118 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
7119 return nativeResponseValue;
7121 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
7123 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: bigint): bigint {
7124 if(!isWasmInitialized) {
7125 throw new Error("initializeWasm() must be awaited first!");
7127 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
7128 return nativeResponseValue;
7130 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
7132 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
7133 if(!isWasmInitialized) {
7134 throw new Error("initializeWasm() must be awaited first!");
7136 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
7137 return nativeResponseValue;
7139 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
7141 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: bigint): bigint {
7142 if(!isWasmInitialized) {
7143 throw new Error("initializeWasm() must be awaited first!");
7145 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
7146 return nativeResponseValue;
7148 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7150 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7151 if(!isWasmInitialized) {
7152 throw new Error("initializeWasm() must be awaited first!");
7154 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
7155 return nativeResponseValue;
7157 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7159 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7160 if(!isWasmInitialized) {
7161 throw new Error("initializeWasm() must be awaited first!");
7163 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
7164 return nativeResponseValue;
7166 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7168 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: bigint): bigint {
7169 if(!isWasmInitialized) {
7170 throw new Error("initializeWasm() must be awaited first!");
7172 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
7173 return nativeResponseValue;
7175 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
7177 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: bigint): bigint {
7178 if(!isWasmInitialized) {
7179 throw new Error("initializeWasm() must be awaited first!");
7181 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
7182 return nativeResponseValue;
7184 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
7186 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: bigint): bigint {
7187 if(!isWasmInitialized) {
7188 throw new Error("initializeWasm() must be awaited first!");
7190 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
7191 return nativeResponseValue;
7193 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
7195 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: bigint): bigint {
7196 if(!isWasmInitialized) {
7197 throw new Error("initializeWasm() must be awaited first!");
7199 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
7200 return nativeResponseValue;
7202 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
7204 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: bigint): bigint {
7205 if(!isWasmInitialized) {
7206 throw new Error("initializeWasm() must be awaited first!");
7208 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
7209 return nativeResponseValue;
7211 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
7213 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: bigint): bigint {
7214 if(!isWasmInitialized) {
7215 throw new Error("initializeWasm() must be awaited first!");
7217 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
7218 return nativeResponseValue;
7220 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
7222 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
7223 if(!isWasmInitialized) {
7224 throw new Error("initializeWasm() must be awaited first!");
7226 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
7227 return nativeResponseValue;
7229 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
7231 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
7232 if(!isWasmInitialized) {
7233 throw new Error("initializeWasm() must be awaited first!");
7235 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
7236 return nativeResponseValue;
7238 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
7240 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: bigint): bigint {
7241 if(!isWasmInitialized) {
7242 throw new Error("initializeWasm() must be awaited first!");
7244 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
7245 return nativeResponseValue;
7247 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
7249 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: bigint): bigint {
7250 if(!isWasmInitialized) {
7251 throw new Error("initializeWasm() must be awaited first!");
7253 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
7254 return nativeResponseValue;
7256 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
7258 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: bigint): bigint {
7259 if(!isWasmInitialized) {
7260 throw new Error("initializeWasm() must be awaited first!");
7262 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
7263 return nativeResponseValue;
7265 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
7267 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: bigint): bigint {
7268 if(!isWasmInitialized) {
7269 throw new Error("initializeWasm() must be awaited first!");
7271 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
7272 return nativeResponseValue;
7275 export class LDKSignOrCreationError {
7276 protected constructor() {}
7279 export function LDKSignOrCreationError_ty_from_ptr(ptr: bigint): number {
7280 if(!isWasmInitialized) {
7281 throw new Error("initializeWasm() must be awaited first!");
7283 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
7284 return nativeResponseValue;
7287 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: bigint): CreationError {
7288 if(!isWasmInitialized) {
7289 throw new Error("initializeWasm() must be awaited first!");
7291 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
7292 return nativeResponseValue;
7294 // struct LDKBolt11Invoice CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
7296 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(owner: bigint): bigint {
7297 if(!isWasmInitialized) {
7298 throw new Error("initializeWasm() must be awaited first!");
7300 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(owner);
7301 return nativeResponseValue;
7303 // struct LDKSignOrCreationError CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
7305 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner: bigint): bigint {
7306 if(!isWasmInitialized) {
7307 throw new Error("initializeWasm() must be awaited first!");
7309 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner);
7310 return nativeResponseValue;
7312 // struct LDKOffersMessage CResult_OffersMessageDecodeErrorZ_get_ok(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner);
7314 export function CResult_OffersMessageDecodeErrorZ_get_ok(owner: bigint): bigint {
7315 if(!isWasmInitialized) {
7316 throw new Error("initializeWasm() must be awaited first!");
7318 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_get_ok(owner);
7319 return nativeResponseValue;
7321 // struct LDKDecodeError CResult_OffersMessageDecodeErrorZ_get_err(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner);
7323 export function CResult_OffersMessageDecodeErrorZ_get_err(owner: bigint): bigint {
7324 if(!isWasmInitialized) {
7325 throw new Error("initializeWasm() must be awaited first!");
7327 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_get_err(owner);
7328 return nativeResponseValue;
7331 export class LDKCOption_HTLCClaimZ {
7332 protected constructor() {}
7335 export function LDKCOption_HTLCClaimZ_ty_from_ptr(ptr: bigint): number {
7336 if(!isWasmInitialized) {
7337 throw new Error("initializeWasm() must be awaited first!");
7339 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_ty_from_ptr(ptr);
7340 return nativeResponseValue;
7343 export function LDKCOption_HTLCClaimZ_Some_get_some(ptr: bigint): HTLCClaim {
7344 if(!isWasmInitialized) {
7345 throw new Error("initializeWasm() must be awaited first!");
7347 const nativeResponseValue = wasm.TS_LDKCOption_HTLCClaimZ_Some_get_some(ptr);
7348 return nativeResponseValue;
7350 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
7352 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: bigint): bigint {
7353 if(!isWasmInitialized) {
7354 throw new Error("initializeWasm() must be awaited first!");
7356 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
7357 return nativeResponseValue;
7359 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
7361 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: bigint): bigint {
7362 if(!isWasmInitialized) {
7363 throw new Error("initializeWasm() must be awaited first!");
7365 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
7366 return nativeResponseValue;
7368 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
7370 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
7371 if(!isWasmInitialized) {
7372 throw new Error("initializeWasm() must be awaited first!");
7374 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
7375 return nativeResponseValue;
7377 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
7379 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: bigint): bigint {
7380 if(!isWasmInitialized) {
7381 throw new Error("initializeWasm() must be awaited first!");
7383 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
7384 return nativeResponseValue;
7386 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
7388 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: bigint): bigint {
7389 if(!isWasmInitialized) {
7390 throw new Error("initializeWasm() must be awaited first!");
7392 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
7393 return nativeResponseValue;
7395 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
7397 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: bigint): bigint {
7398 if(!isWasmInitialized) {
7399 throw new Error("initializeWasm() must be awaited first!");
7401 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
7402 return nativeResponseValue;
7404 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
7406 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: bigint): bigint {
7407 if(!isWasmInitialized) {
7408 throw new Error("initializeWasm() must be awaited first!");
7410 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
7411 return nativeResponseValue;
7413 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
7415 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: bigint): bigint {
7416 if(!isWasmInitialized) {
7417 throw new Error("initializeWasm() must be awaited first!");
7419 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
7420 return nativeResponseValue;
7422 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
7424 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
7425 if(!isWasmInitialized) {
7426 throw new Error("initializeWasm() must be awaited first!");
7428 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
7429 return nativeResponseValue;
7431 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
7433 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
7434 if(!isWasmInitialized) {
7435 throw new Error("initializeWasm() must be awaited first!");
7437 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
7438 return nativeResponseValue;
7440 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
7442 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: bigint): bigint {
7443 if(!isWasmInitialized) {
7444 throw new Error("initializeWasm() must be awaited first!");
7446 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
7447 return nativeResponseValue;
7449 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
7451 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: bigint): bigint {
7452 if(!isWasmInitialized) {
7453 throw new Error("initializeWasm() must be awaited first!");
7455 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
7456 return nativeResponseValue;
7458 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
7460 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
7461 if(!isWasmInitialized) {
7462 throw new Error("initializeWasm() must be awaited first!");
7464 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
7465 return nativeResponseValue;
7467 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
7469 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
7470 if(!isWasmInitialized) {
7471 throw new Error("initializeWasm() must be awaited first!");
7473 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
7474 return nativeResponseValue;
7476 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
7478 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
7479 if(!isWasmInitialized) {
7480 throw new Error("initializeWasm() must be awaited first!");
7482 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
7483 return nativeResponseValue;
7485 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
7487 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
7488 if(!isWasmInitialized) {
7489 throw new Error("initializeWasm() must be awaited first!");
7491 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
7492 return nativeResponseValue;
7494 // struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
7496 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: bigint): bigint {
7497 if(!isWasmInitialized) {
7498 throw new Error("initializeWasm() must be awaited first!");
7500 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
7501 return nativeResponseValue;
7503 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
7505 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: bigint): void {
7506 if(!isWasmInitialized) {
7507 throw new Error("initializeWasm() must be awaited first!");
7509 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
7510 // debug statements here
7512 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
7514 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: bigint): bigint {
7515 if(!isWasmInitialized) {
7516 throw new Error("initializeWasm() must be awaited first!");
7518 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
7519 return nativeResponseValue;
7521 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
7523 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: bigint): bigint {
7524 if(!isWasmInitialized) {
7525 throw new Error("initializeWasm() must be awaited first!");
7527 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
7528 return nativeResponseValue;
7530 // struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
7532 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: bigint): bigint {
7533 if(!isWasmInitialized) {
7534 throw new Error("initializeWasm() must be awaited first!");
7536 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
7537 return nativeResponseValue;
7539 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
7541 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: bigint): void {
7542 if(!isWasmInitialized) {
7543 throw new Error("initializeWasm() must be awaited first!");
7545 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
7546 // debug statements here
7548 // struct LDKCVec_ECDSASignatureZ CResult_CVec_ECDSASignatureZNoneZ_get_ok(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR owner);
7550 export function CResult_CVec_ECDSASignatureZNoneZ_get_ok(owner: bigint): number {
7551 if(!isWasmInitialized) {
7552 throw new Error("initializeWasm() must be awaited first!");
7554 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_get_ok(owner);
7555 return nativeResponseValue;
7557 // void CResult_CVec_ECDSASignatureZNoneZ_get_err(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR owner);
7559 export function CResult_CVec_ECDSASignatureZNoneZ_get_err(owner: bigint): void {
7560 if(!isWasmInitialized) {
7561 throw new Error("initializeWasm() must be awaited first!");
7563 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_get_err(owner);
7564 // debug statements here
7567 export class LDKCOption_usizeZ {
7568 protected constructor() {}
7571 export function LDKCOption_usizeZ_ty_from_ptr(ptr: bigint): number {
7572 if(!isWasmInitialized) {
7573 throw new Error("initializeWasm() must be awaited first!");
7575 const nativeResponseValue = wasm.TS_LDKCOption_usizeZ_ty_from_ptr(ptr);
7576 return nativeResponseValue;
7579 export function LDKCOption_usizeZ_Some_get_some(ptr: bigint): number {
7580 if(!isWasmInitialized) {
7581 throw new Error("initializeWasm() must be awaited first!");
7583 const nativeResponseValue = wasm.TS_LDKCOption_usizeZ_Some_get_some(ptr);
7584 return nativeResponseValue;
7586 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
7588 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: bigint): bigint {
7589 if(!isWasmInitialized) {
7590 throw new Error("initializeWasm() must be awaited first!");
7592 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
7593 return nativeResponseValue;
7595 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
7597 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: bigint): bigint {
7598 if(!isWasmInitialized) {
7599 throw new Error("initializeWasm() must be awaited first!");
7601 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
7602 return nativeResponseValue;
7604 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
7606 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: bigint): bigint {
7607 if(!isWasmInitialized) {
7608 throw new Error("initializeWasm() must be awaited first!");
7610 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
7611 return nativeResponseValue;
7613 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
7615 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: bigint): bigint {
7616 if(!isWasmInitialized) {
7617 throw new Error("initializeWasm() must be awaited first!");
7619 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
7620 return nativeResponseValue;
7623 export class LDKPaymentPurpose {
7624 protected constructor() {}
7627 export function LDKPaymentPurpose_ty_from_ptr(ptr: bigint): number {
7628 if(!isWasmInitialized) {
7629 throw new Error("initializeWasm() must be awaited first!");
7631 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
7632 return nativeResponseValue;
7635 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: bigint): bigint {
7636 if(!isWasmInitialized) {
7637 throw new Error("initializeWasm() must be awaited first!");
7639 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
7640 return nativeResponseValue;
7643 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: bigint): number {
7644 if(!isWasmInitialized) {
7645 throw new Error("initializeWasm() must be awaited first!");
7647 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
7648 return nativeResponseValue;
7651 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: bigint): number {
7652 if(!isWasmInitialized) {
7653 throw new Error("initializeWasm() must be awaited first!");
7655 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
7656 return nativeResponseValue;
7658 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
7660 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: bigint): bigint {
7661 if(!isWasmInitialized) {
7662 throw new Error("initializeWasm() must be awaited first!");
7664 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
7665 return nativeResponseValue;
7667 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
7669 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: bigint): bigint {
7670 if(!isWasmInitialized) {
7671 throw new Error("initializeWasm() must be awaited first!");
7673 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
7674 return nativeResponseValue;
7676 // struct LDKClaimedHTLC CResult_ClaimedHTLCDecodeErrorZ_get_ok(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR owner);
7678 export function CResult_ClaimedHTLCDecodeErrorZ_get_ok(owner: bigint): bigint {
7679 if(!isWasmInitialized) {
7680 throw new Error("initializeWasm() must be awaited first!");
7682 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_get_ok(owner);
7683 return nativeResponseValue;
7685 // struct LDKDecodeError CResult_ClaimedHTLCDecodeErrorZ_get_err(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR owner);
7687 export function CResult_ClaimedHTLCDecodeErrorZ_get_err(owner: bigint): bigint {
7688 if(!isWasmInitialized) {
7689 throw new Error("initializeWasm() must be awaited first!");
7691 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_get_err(owner);
7692 return nativeResponseValue;
7695 export class LDKPathFailure {
7696 protected constructor() {}
7699 export function LDKPathFailure_ty_from_ptr(ptr: bigint): number {
7700 if(!isWasmInitialized) {
7701 throw new Error("initializeWasm() must be awaited first!");
7703 const nativeResponseValue = wasm.TS_LDKPathFailure_ty_from_ptr(ptr);
7704 return nativeResponseValue;
7707 export function LDKPathFailure_InitialSend_get_err(ptr: bigint): bigint {
7708 if(!isWasmInitialized) {
7709 throw new Error("initializeWasm() must be awaited first!");
7711 const nativeResponseValue = wasm.TS_LDKPathFailure_InitialSend_get_err(ptr);
7712 return nativeResponseValue;
7715 export function LDKPathFailure_OnPath_get_network_update(ptr: bigint): bigint {
7716 if(!isWasmInitialized) {
7717 throw new Error("initializeWasm() must be awaited first!");
7719 const nativeResponseValue = wasm.TS_LDKPathFailure_OnPath_get_network_update(ptr);
7720 return nativeResponseValue;
7723 export class LDKCOption_PathFailureZ {
7724 protected constructor() {}
7727 export function LDKCOption_PathFailureZ_ty_from_ptr(ptr: bigint): number {
7728 if(!isWasmInitialized) {
7729 throw new Error("initializeWasm() must be awaited first!");
7731 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_ty_from_ptr(ptr);
7732 return nativeResponseValue;
7735 export function LDKCOption_PathFailureZ_Some_get_some(ptr: bigint): bigint {
7736 if(!isWasmInitialized) {
7737 throw new Error("initializeWasm() must be awaited first!");
7739 const nativeResponseValue = wasm.TS_LDKCOption_PathFailureZ_Some_get_some(ptr);
7740 return nativeResponseValue;
7742 // struct LDKCOption_PathFailureZ CResult_COption_PathFailureZDecodeErrorZ_get_ok(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
7744 export function CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner: bigint): bigint {
7745 if(!isWasmInitialized) {
7746 throw new Error("initializeWasm() must be awaited first!");
7748 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner);
7749 return nativeResponseValue;
7751 // struct LDKDecodeError CResult_COption_PathFailureZDecodeErrorZ_get_err(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner);
7753 export function CResult_COption_PathFailureZDecodeErrorZ_get_err(owner: bigint): bigint {
7754 if(!isWasmInitialized) {
7755 throw new Error("initializeWasm() must be awaited first!");
7757 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_get_err(owner);
7758 return nativeResponseValue;
7761 export class LDKClosureReason {
7762 protected constructor() {}
7765 export function LDKClosureReason_ty_from_ptr(ptr: bigint): number {
7766 if(!isWasmInitialized) {
7767 throw new Error("initializeWasm() must be awaited first!");
7769 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
7770 return nativeResponseValue;
7773 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: bigint): bigint {
7774 if(!isWasmInitialized) {
7775 throw new Error("initializeWasm() must be awaited first!");
7777 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
7778 return nativeResponseValue;
7781 export function LDKClosureReason_ProcessingError_get_err(ptr: bigint): number {
7782 if(!isWasmInitialized) {
7783 throw new Error("initializeWasm() must be awaited first!");
7785 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
7786 return nativeResponseValue;
7789 export class LDKCOption_ClosureReasonZ {
7790 protected constructor() {}
7793 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: bigint): number {
7794 if(!isWasmInitialized) {
7795 throw new Error("initializeWasm() must be awaited first!");
7797 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
7798 return nativeResponseValue;
7801 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: bigint): bigint {
7802 if(!isWasmInitialized) {
7803 throw new Error("initializeWasm() must be awaited first!");
7805 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
7806 return nativeResponseValue;
7808 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
7810 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: bigint): bigint {
7811 if(!isWasmInitialized) {
7812 throw new Error("initializeWasm() must be awaited first!");
7814 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
7815 return nativeResponseValue;
7817 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
7819 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: bigint): bigint {
7820 if(!isWasmInitialized) {
7821 throw new Error("initializeWasm() must be awaited first!");
7823 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
7824 return nativeResponseValue;
7827 export class LDKHTLCDestination {
7828 protected constructor() {}
7831 export function LDKHTLCDestination_ty_from_ptr(ptr: bigint): number {
7832 if(!isWasmInitialized) {
7833 throw new Error("initializeWasm() must be awaited first!");
7835 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
7836 return nativeResponseValue;
7839 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: bigint): number {
7840 if(!isWasmInitialized) {
7841 throw new Error("initializeWasm() must be awaited first!");
7843 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
7844 return nativeResponseValue;
7847 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: bigint): number {
7848 if(!isWasmInitialized) {
7849 throw new Error("initializeWasm() must be awaited first!");
7851 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
7852 return nativeResponseValue;
7855 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: bigint): bigint {
7856 if(!isWasmInitialized) {
7857 throw new Error("initializeWasm() must be awaited first!");
7859 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
7860 return nativeResponseValue;
7863 export function LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr: bigint): bigint {
7864 if(!isWasmInitialized) {
7865 throw new Error("initializeWasm() must be awaited first!");
7867 const nativeResponseValue = wasm.TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(ptr);
7868 return nativeResponseValue;
7871 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: bigint): number {
7872 if(!isWasmInitialized) {
7873 throw new Error("initializeWasm() must be awaited first!");
7875 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
7876 return nativeResponseValue;
7879 export class LDKCOption_HTLCDestinationZ {
7880 protected constructor() {}
7883 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: bigint): number {
7884 if(!isWasmInitialized) {
7885 throw new Error("initializeWasm() must be awaited first!");
7887 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
7888 return nativeResponseValue;
7891 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: bigint): bigint {
7892 if(!isWasmInitialized) {
7893 throw new Error("initializeWasm() must be awaited first!");
7895 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
7896 return nativeResponseValue;
7898 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
7900 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: bigint): bigint {
7901 if(!isWasmInitialized) {
7902 throw new Error("initializeWasm() must be awaited first!");
7904 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
7905 return nativeResponseValue;
7907 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
7909 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: bigint): bigint {
7910 if(!isWasmInitialized) {
7911 throw new Error("initializeWasm() must be awaited first!");
7913 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
7914 return nativeResponseValue;
7916 // enum LDKPaymentFailureReason CResult_PaymentFailureReasonDecodeErrorZ_get_ok(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
7918 export function CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner: bigint): PaymentFailureReason {
7919 if(!isWasmInitialized) {
7920 throw new Error("initializeWasm() must be awaited first!");
7922 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner);
7923 return nativeResponseValue;
7925 // struct LDKDecodeError CResult_PaymentFailureReasonDecodeErrorZ_get_err(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner);
7927 export function CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner: bigint): bigint {
7928 if(!isWasmInitialized) {
7929 throw new Error("initializeWasm() must be awaited first!");
7931 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner);
7932 return nativeResponseValue;
7935 export class LDKCOption_U128Z {
7936 protected constructor() {}
7939 export function LDKCOption_U128Z_ty_from_ptr(ptr: bigint): number {
7940 if(!isWasmInitialized) {
7941 throw new Error("initializeWasm() must be awaited first!");
7943 const nativeResponseValue = wasm.TS_LDKCOption_U128Z_ty_from_ptr(ptr);
7944 return nativeResponseValue;
7947 export function LDKCOption_U128Z_Some_get_some(ptr: bigint): number {
7948 if(!isWasmInitialized) {
7949 throw new Error("initializeWasm() must be awaited first!");
7951 const nativeResponseValue = wasm.TS_LDKCOption_U128Z_Some_get_some(ptr);
7952 return nativeResponseValue;
7955 export class LDKCOption_PaymentFailureReasonZ {
7956 protected constructor() {}
7959 export function LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr: bigint): number {
7960 if(!isWasmInitialized) {
7961 throw new Error("initializeWasm() must be awaited first!");
7963 const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr(ptr);
7964 return nativeResponseValue;
7967 export function LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr: bigint): PaymentFailureReason {
7968 if(!isWasmInitialized) {
7969 throw new Error("initializeWasm() must be awaited first!");
7971 const nativeResponseValue = wasm.TS_LDKCOption_PaymentFailureReasonZ_Some_get_some(ptr);
7972 return nativeResponseValue;
7975 export class LDKBumpTransactionEvent {
7976 protected constructor() {}
7979 export function LDKBumpTransactionEvent_ty_from_ptr(ptr: bigint): number {
7980 if(!isWasmInitialized) {
7981 throw new Error("initializeWasm() must be awaited first!");
7983 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ty_from_ptr(ptr);
7984 return nativeResponseValue;
7987 export function LDKBumpTransactionEvent_ChannelClose_get_claim_id(ptr: bigint): number {
7988 if(!isWasmInitialized) {
7989 throw new Error("initializeWasm() must be awaited first!");
7991 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_claim_id(ptr);
7992 return nativeResponseValue;
7995 export function LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(ptr: bigint): number {
7996 if(!isWasmInitialized) {
7997 throw new Error("initializeWasm() must be awaited first!");
7999 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(ptr);
8000 return nativeResponseValue;
8003 export function LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(ptr: bigint): number {
8004 if(!isWasmInitialized) {
8005 throw new Error("initializeWasm() must be awaited first!");
8007 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(ptr);
8008 return nativeResponseValue;
8011 export function LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(ptr: bigint): bigint {
8012 if(!isWasmInitialized) {
8013 throw new Error("initializeWasm() must be awaited first!");
8015 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(ptr);
8016 return nativeResponseValue;
8019 export function LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(ptr: bigint): bigint {
8020 if(!isWasmInitialized) {
8021 throw new Error("initializeWasm() must be awaited first!");
8023 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(ptr);
8024 return nativeResponseValue;
8027 export function LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(ptr: bigint): number {
8028 if(!isWasmInitialized) {
8029 throw new Error("initializeWasm() must be awaited first!");
8031 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(ptr);
8032 return nativeResponseValue;
8035 export function LDKBumpTransactionEvent_HTLCResolution_get_claim_id(ptr: bigint): number {
8036 if(!isWasmInitialized) {
8037 throw new Error("initializeWasm() must be awaited first!");
8039 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_claim_id(ptr);
8040 return nativeResponseValue;
8043 export function LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(ptr: bigint): number {
8044 if(!isWasmInitialized) {
8045 throw new Error("initializeWasm() must be awaited first!");
8047 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(ptr);
8048 return nativeResponseValue;
8051 export function LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(ptr: bigint): number {
8052 if(!isWasmInitialized) {
8053 throw new Error("initializeWasm() must be awaited first!");
8055 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(ptr);
8056 return nativeResponseValue;
8059 export function LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(ptr: bigint): number {
8060 if(!isWasmInitialized) {
8061 throw new Error("initializeWasm() must be awaited first!");
8063 const nativeResponseValue = wasm.TS_LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(ptr);
8064 return nativeResponseValue;
8067 export class LDKEvent {
8068 protected constructor() {}
8071 export function LDKEvent_ty_from_ptr(ptr: bigint): number {
8072 if(!isWasmInitialized) {
8073 throw new Error("initializeWasm() must be awaited first!");
8075 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
8076 return nativeResponseValue;
8079 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: bigint): number {
8080 if(!isWasmInitialized) {
8081 throw new Error("initializeWasm() must be awaited first!");
8083 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
8084 return nativeResponseValue;
8087 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: bigint): number {
8088 if(!isWasmInitialized) {
8089 throw new Error("initializeWasm() must be awaited first!");
8091 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
8092 return nativeResponseValue;
8095 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: bigint): bigint {
8096 if(!isWasmInitialized) {
8097 throw new Error("initializeWasm() must be awaited first!");
8099 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
8100 return nativeResponseValue;
8103 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: bigint): number {
8104 if(!isWasmInitialized) {
8105 throw new Error("initializeWasm() must be awaited first!");
8107 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
8108 return nativeResponseValue;
8111 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: bigint): number {
8112 if(!isWasmInitialized) {
8113 throw new Error("initializeWasm() must be awaited first!");
8115 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
8116 return nativeResponseValue;
8119 export function LDKEvent_PaymentClaimable_get_receiver_node_id(ptr: bigint): number {
8120 if(!isWasmInitialized) {
8121 throw new Error("initializeWasm() must be awaited first!");
8123 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_receiver_node_id(ptr);
8124 return nativeResponseValue;
8127 export function LDKEvent_PaymentClaimable_get_payment_hash(ptr: bigint): number {
8128 if(!isWasmInitialized) {
8129 throw new Error("initializeWasm() must be awaited first!");
8131 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_payment_hash(ptr);
8132 return nativeResponseValue;
8135 export function LDKEvent_PaymentClaimable_get_onion_fields(ptr: bigint): bigint {
8136 if(!isWasmInitialized) {
8137 throw new Error("initializeWasm() must be awaited first!");
8139 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_onion_fields(ptr);
8140 return nativeResponseValue;
8143 export function LDKEvent_PaymentClaimable_get_amount_msat(ptr: bigint): bigint {
8144 if(!isWasmInitialized) {
8145 throw new Error("initializeWasm() must be awaited first!");
8147 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_amount_msat(ptr);
8148 return nativeResponseValue;
8151 export function LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat(ptr: bigint): bigint {
8152 if(!isWasmInitialized) {
8153 throw new Error("initializeWasm() must be awaited first!");
8155 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat(ptr);
8156 return nativeResponseValue;
8159 export function LDKEvent_PaymentClaimable_get_purpose(ptr: bigint): bigint {
8160 if(!isWasmInitialized) {
8161 throw new Error("initializeWasm() must be awaited first!");
8163 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_purpose(ptr);
8164 return nativeResponseValue;
8167 export function LDKEvent_PaymentClaimable_get_via_channel_id(ptr: bigint): bigint {
8168 if(!isWasmInitialized) {
8169 throw new Error("initializeWasm() must be awaited first!");
8171 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_channel_id(ptr);
8172 return nativeResponseValue;
8175 export function LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr: bigint): bigint {
8176 if(!isWasmInitialized) {
8177 throw new Error("initializeWasm() must be awaited first!");
8179 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_via_user_channel_id(ptr);
8180 return nativeResponseValue;
8183 export function LDKEvent_PaymentClaimable_get_claim_deadline(ptr: bigint): bigint {
8184 if(!isWasmInitialized) {
8185 throw new Error("initializeWasm() must be awaited first!");
8187 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimable_get_claim_deadline(ptr);
8188 return nativeResponseValue;
8191 export function LDKEvent_PaymentClaimed_get_receiver_node_id(ptr: bigint): number {
8192 if(!isWasmInitialized) {
8193 throw new Error("initializeWasm() must be awaited first!");
8195 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_receiver_node_id(ptr);
8196 return nativeResponseValue;
8199 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: bigint): number {
8200 if(!isWasmInitialized) {
8201 throw new Error("initializeWasm() must be awaited first!");
8203 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
8204 return nativeResponseValue;
8207 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: bigint): bigint {
8208 if(!isWasmInitialized) {
8209 throw new Error("initializeWasm() must be awaited first!");
8211 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
8212 return nativeResponseValue;
8215 export function LDKEvent_PaymentClaimed_get_purpose(ptr: bigint): bigint {
8216 if(!isWasmInitialized) {
8217 throw new Error("initializeWasm() must be awaited first!");
8219 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
8220 return nativeResponseValue;
8223 export function LDKEvent_PaymentClaimed_get_htlcs(ptr: bigint): number {
8224 if(!isWasmInitialized) {
8225 throw new Error("initializeWasm() must be awaited first!");
8227 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_htlcs(ptr);
8228 return nativeResponseValue;
8231 export function LDKEvent_PaymentClaimed_get_sender_intended_total_msat(ptr: bigint): bigint {
8232 if(!isWasmInitialized) {
8233 throw new Error("initializeWasm() must be awaited first!");
8235 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_sender_intended_total_msat(ptr);
8236 return nativeResponseValue;
8239 export function LDKEvent_ConnectionNeeded_get_node_id(ptr: bigint): number {
8240 if(!isWasmInitialized) {
8241 throw new Error("initializeWasm() must be awaited first!");
8243 const nativeResponseValue = wasm.TS_LDKEvent_ConnectionNeeded_get_node_id(ptr);
8244 return nativeResponseValue;
8247 export function LDKEvent_ConnectionNeeded_get_addresses(ptr: bigint): number {
8248 if(!isWasmInitialized) {
8249 throw new Error("initializeWasm() must be awaited first!");
8251 const nativeResponseValue = wasm.TS_LDKEvent_ConnectionNeeded_get_addresses(ptr);
8252 return nativeResponseValue;
8255 export function LDKEvent_InvoiceRequestFailed_get_payment_id(ptr: bigint): number {
8256 if(!isWasmInitialized) {
8257 throw new Error("initializeWasm() must be awaited first!");
8259 const nativeResponseValue = wasm.TS_LDKEvent_InvoiceRequestFailed_get_payment_id(ptr);
8260 return nativeResponseValue;
8263 export function LDKEvent_PaymentSent_get_payment_id(ptr: bigint): bigint {
8264 if(!isWasmInitialized) {
8265 throw new Error("initializeWasm() must be awaited first!");
8267 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
8268 return nativeResponseValue;
8271 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: bigint): number {
8272 if(!isWasmInitialized) {
8273 throw new Error("initializeWasm() must be awaited first!");
8275 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
8276 return nativeResponseValue;
8279 export function LDKEvent_PaymentSent_get_payment_hash(ptr: bigint): number {
8280 if(!isWasmInitialized) {
8281 throw new Error("initializeWasm() must be awaited first!");
8283 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
8284 return nativeResponseValue;
8287 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: bigint): bigint {
8288 if(!isWasmInitialized) {
8289 throw new Error("initializeWasm() must be awaited first!");
8291 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
8292 return nativeResponseValue;
8295 export function LDKEvent_PaymentFailed_get_payment_id(ptr: bigint): number {
8296 if(!isWasmInitialized) {
8297 throw new Error("initializeWasm() must be awaited first!");
8299 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
8300 return nativeResponseValue;
8303 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: bigint): number {
8304 if(!isWasmInitialized) {
8305 throw new Error("initializeWasm() must be awaited first!");
8307 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
8308 return nativeResponseValue;
8311 export function LDKEvent_PaymentFailed_get_reason(ptr: bigint): bigint {
8312 if(!isWasmInitialized) {
8313 throw new Error("initializeWasm() must be awaited first!");
8315 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_reason(ptr);
8316 return nativeResponseValue;
8319 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: bigint): number {
8320 if(!isWasmInitialized) {
8321 throw new Error("initializeWasm() must be awaited first!");
8323 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
8324 return nativeResponseValue;
8327 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: bigint): bigint {
8328 if(!isWasmInitialized) {
8329 throw new Error("initializeWasm() must be awaited first!");
8331 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
8332 return nativeResponseValue;
8335 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: bigint): bigint {
8336 if(!isWasmInitialized) {
8337 throw new Error("initializeWasm() must be awaited first!");
8339 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
8340 return nativeResponseValue;
8343 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: bigint): bigint {
8344 if(!isWasmInitialized) {
8345 throw new Error("initializeWasm() must be awaited first!");
8347 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
8348 return nativeResponseValue;
8351 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: bigint): number {
8352 if(!isWasmInitialized) {
8353 throw new Error("initializeWasm() must be awaited first!");
8355 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
8356 return nativeResponseValue;
8359 export function LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr: bigint): boolean {
8360 if(!isWasmInitialized) {
8361 throw new Error("initializeWasm() must be awaited first!");
8363 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(ptr);
8364 return nativeResponseValue;
8367 export function LDKEvent_PaymentPathFailed_get_failure(ptr: bigint): bigint {
8368 if(!isWasmInitialized) {
8369 throw new Error("initializeWasm() must be awaited first!");
8371 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_failure(ptr);
8372 return nativeResponseValue;
8375 export function LDKEvent_PaymentPathFailed_get_path(ptr: bigint): bigint {
8376 if(!isWasmInitialized) {
8377 throw new Error("initializeWasm() must be awaited first!");
8379 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
8380 return nativeResponseValue;
8383 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: bigint): bigint {
8384 if(!isWasmInitialized) {
8385 throw new Error("initializeWasm() must be awaited first!");
8387 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
8388 return nativeResponseValue;
8391 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: bigint): number {
8392 if(!isWasmInitialized) {
8393 throw new Error("initializeWasm() must be awaited first!");
8395 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
8396 return nativeResponseValue;
8399 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: bigint): number {
8400 if(!isWasmInitialized) {
8401 throw new Error("initializeWasm() must be awaited first!");
8403 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
8404 return nativeResponseValue;
8407 export function LDKEvent_ProbeSuccessful_get_path(ptr: bigint): bigint {
8408 if(!isWasmInitialized) {
8409 throw new Error("initializeWasm() must be awaited first!");
8411 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
8412 return nativeResponseValue;
8415 export function LDKEvent_ProbeFailed_get_payment_id(ptr: bigint): number {
8416 if(!isWasmInitialized) {
8417 throw new Error("initializeWasm() must be awaited first!");
8419 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
8420 return nativeResponseValue;
8423 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: bigint): number {
8424 if(!isWasmInitialized) {
8425 throw new Error("initializeWasm() must be awaited first!");
8427 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
8428 return nativeResponseValue;
8431 export function LDKEvent_ProbeFailed_get_path(ptr: bigint): bigint {
8432 if(!isWasmInitialized) {
8433 throw new Error("initializeWasm() must be awaited first!");
8435 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
8436 return nativeResponseValue;
8439 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: bigint): bigint {
8440 if(!isWasmInitialized) {
8441 throw new Error("initializeWasm() must be awaited first!");
8443 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
8444 return nativeResponseValue;
8447 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: bigint): bigint {
8448 if(!isWasmInitialized) {
8449 throw new Error("initializeWasm() must be awaited first!");
8451 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
8452 return nativeResponseValue;
8455 export function LDKEvent_HTLCIntercepted_get_intercept_id(ptr: bigint): number {
8456 if(!isWasmInitialized) {
8457 throw new Error("initializeWasm() must be awaited first!");
8459 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_intercept_id(ptr);
8460 return nativeResponseValue;
8463 export function LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr: bigint): bigint {
8464 if(!isWasmInitialized) {
8465 throw new Error("initializeWasm() must be awaited first!");
8467 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(ptr);
8468 return nativeResponseValue;
8471 export function LDKEvent_HTLCIntercepted_get_payment_hash(ptr: bigint): number {
8472 if(!isWasmInitialized) {
8473 throw new Error("initializeWasm() must be awaited first!");
8475 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_payment_hash(ptr);
8476 return nativeResponseValue;
8479 export function LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr: bigint): bigint {
8480 if(!isWasmInitialized) {
8481 throw new Error("initializeWasm() must be awaited first!");
8483 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat(ptr);
8484 return nativeResponseValue;
8487 export function LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr: bigint): bigint {
8488 if(!isWasmInitialized) {
8489 throw new Error("initializeWasm() must be awaited first!");
8491 const nativeResponseValue = wasm.TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(ptr);
8492 return nativeResponseValue;
8495 export function LDKEvent_SpendableOutputs_get_outputs(ptr: bigint): number {
8496 if(!isWasmInitialized) {
8497 throw new Error("initializeWasm() must be awaited first!");
8499 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
8500 return nativeResponseValue;
8503 export function LDKEvent_SpendableOutputs_get_channel_id(ptr: bigint): bigint {
8504 if(!isWasmInitialized) {
8505 throw new Error("initializeWasm() must be awaited first!");
8507 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_channel_id(ptr);
8508 return nativeResponseValue;
8511 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: bigint): bigint {
8512 if(!isWasmInitialized) {
8513 throw new Error("initializeWasm() must be awaited first!");
8515 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
8516 return nativeResponseValue;
8519 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: bigint): bigint {
8520 if(!isWasmInitialized) {
8521 throw new Error("initializeWasm() must be awaited first!");
8523 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
8524 return nativeResponseValue;
8527 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: bigint): bigint {
8528 if(!isWasmInitialized) {
8529 throw new Error("initializeWasm() must be awaited first!");
8531 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
8532 return nativeResponseValue;
8535 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: bigint): boolean {
8536 if(!isWasmInitialized) {
8537 throw new Error("initializeWasm() must be awaited first!");
8539 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
8540 return nativeResponseValue;
8543 export function LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr: bigint): bigint {
8544 if(!isWasmInitialized) {
8545 throw new Error("initializeWasm() must be awaited first!");
8547 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(ptr);
8548 return nativeResponseValue;
8551 export function LDKEvent_ChannelPending_get_channel_id(ptr: bigint): number {
8552 if(!isWasmInitialized) {
8553 throw new Error("initializeWasm() must be awaited first!");
8555 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_channel_id(ptr);
8556 return nativeResponseValue;
8559 export function LDKEvent_ChannelPending_get_user_channel_id(ptr: bigint): number {
8560 if(!isWasmInitialized) {
8561 throw new Error("initializeWasm() must be awaited first!");
8563 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_user_channel_id(ptr);
8564 return nativeResponseValue;
8567 export function LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr: bigint): bigint {
8568 if(!isWasmInitialized) {
8569 throw new Error("initializeWasm() must be awaited first!");
8571 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_former_temporary_channel_id(ptr);
8572 return nativeResponseValue;
8575 export function LDKEvent_ChannelPending_get_counterparty_node_id(ptr: bigint): number {
8576 if(!isWasmInitialized) {
8577 throw new Error("initializeWasm() must be awaited first!");
8579 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_counterparty_node_id(ptr);
8580 return nativeResponseValue;
8583 export function LDKEvent_ChannelPending_get_funding_txo(ptr: bigint): bigint {
8584 if(!isWasmInitialized) {
8585 throw new Error("initializeWasm() must be awaited first!");
8587 const nativeResponseValue = wasm.TS_LDKEvent_ChannelPending_get_funding_txo(ptr);
8588 return nativeResponseValue;
8591 export function LDKEvent_ChannelReady_get_channel_id(ptr: bigint): number {
8592 if(!isWasmInitialized) {
8593 throw new Error("initializeWasm() must be awaited first!");
8595 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_id(ptr);
8596 return nativeResponseValue;
8599 export function LDKEvent_ChannelReady_get_user_channel_id(ptr: bigint): number {
8600 if(!isWasmInitialized) {
8601 throw new Error("initializeWasm() must be awaited first!");
8603 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_user_channel_id(ptr);
8604 return nativeResponseValue;
8607 export function LDKEvent_ChannelReady_get_counterparty_node_id(ptr: bigint): number {
8608 if(!isWasmInitialized) {
8609 throw new Error("initializeWasm() must be awaited first!");
8611 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_counterparty_node_id(ptr);
8612 return nativeResponseValue;
8615 export function LDKEvent_ChannelReady_get_channel_type(ptr: bigint): bigint {
8616 if(!isWasmInitialized) {
8617 throw new Error("initializeWasm() must be awaited first!");
8619 const nativeResponseValue = wasm.TS_LDKEvent_ChannelReady_get_channel_type(ptr);
8620 return nativeResponseValue;
8623 export function LDKEvent_ChannelClosed_get_channel_id(ptr: bigint): number {
8624 if(!isWasmInitialized) {
8625 throw new Error("initializeWasm() must be awaited first!");
8627 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
8628 return nativeResponseValue;
8631 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: bigint): number {
8632 if(!isWasmInitialized) {
8633 throw new Error("initializeWasm() must be awaited first!");
8635 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
8636 return nativeResponseValue;
8639 export function LDKEvent_ChannelClosed_get_reason(ptr: bigint): bigint {
8640 if(!isWasmInitialized) {
8641 throw new Error("initializeWasm() must be awaited first!");
8643 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
8644 return nativeResponseValue;
8647 export function LDKEvent_ChannelClosed_get_counterparty_node_id(ptr: bigint): number {
8648 if(!isWasmInitialized) {
8649 throw new Error("initializeWasm() must be awaited first!");
8651 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_counterparty_node_id(ptr);
8652 return nativeResponseValue;
8655 export function LDKEvent_ChannelClosed_get_channel_capacity_sats(ptr: bigint): bigint {
8656 if(!isWasmInitialized) {
8657 throw new Error("initializeWasm() must be awaited first!");
8659 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_capacity_sats(ptr);
8660 return nativeResponseValue;
8663 export function LDKEvent_ChannelClosed_get_channel_funding_txo(ptr: bigint): bigint {
8664 if(!isWasmInitialized) {
8665 throw new Error("initializeWasm() must be awaited first!");
8667 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_funding_txo(ptr);
8668 return nativeResponseValue;
8671 export function LDKEvent_DiscardFunding_get_channel_id(ptr: bigint): number {
8672 if(!isWasmInitialized) {
8673 throw new Error("initializeWasm() must be awaited first!");
8675 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
8676 return nativeResponseValue;
8679 export function LDKEvent_DiscardFunding_get_transaction(ptr: bigint): number {
8680 if(!isWasmInitialized) {
8681 throw new Error("initializeWasm() must be awaited first!");
8683 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
8684 return nativeResponseValue;
8687 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: bigint): number {
8688 if(!isWasmInitialized) {
8689 throw new Error("initializeWasm() must be awaited first!");
8691 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
8692 return nativeResponseValue;
8695 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: bigint): number {
8696 if(!isWasmInitialized) {
8697 throw new Error("initializeWasm() must be awaited first!");
8699 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
8700 return nativeResponseValue;
8703 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: bigint): bigint {
8704 if(!isWasmInitialized) {
8705 throw new Error("initializeWasm() must be awaited first!");
8707 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
8708 return nativeResponseValue;
8711 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: bigint): bigint {
8712 if(!isWasmInitialized) {
8713 throw new Error("initializeWasm() must be awaited first!");
8715 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
8716 return nativeResponseValue;
8719 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: bigint): bigint {
8720 if(!isWasmInitialized) {
8721 throw new Error("initializeWasm() must be awaited first!");
8723 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
8724 return nativeResponseValue;
8727 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: bigint): number {
8728 if(!isWasmInitialized) {
8729 throw new Error("initializeWasm() must be awaited first!");
8731 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
8732 return nativeResponseValue;
8735 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: bigint): bigint {
8736 if(!isWasmInitialized) {
8737 throw new Error("initializeWasm() must be awaited first!");
8739 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
8740 return nativeResponseValue;
8743 export function LDKEvent_BumpTransaction_get_bump_transaction(ptr: bigint): bigint {
8744 if(!isWasmInitialized) {
8745 throw new Error("initializeWasm() must be awaited first!");
8747 const nativeResponseValue = wasm.TS_LDKEvent_BumpTransaction_get_bump_transaction(ptr);
8748 return nativeResponseValue;
8751 export class LDKCOption_EventZ {
8752 protected constructor() {}
8755 export function LDKCOption_EventZ_ty_from_ptr(ptr: bigint): number {
8756 if(!isWasmInitialized) {
8757 throw new Error("initializeWasm() must be awaited first!");
8759 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
8760 return nativeResponseValue;
8763 export function LDKCOption_EventZ_Some_get_some(ptr: bigint): bigint {
8764 if(!isWasmInitialized) {
8765 throw new Error("initializeWasm() must be awaited first!");
8767 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
8768 return nativeResponseValue;
8770 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
8772 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: bigint): bigint {
8773 if(!isWasmInitialized) {
8774 throw new Error("initializeWasm() must be awaited first!");
8776 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
8777 return nativeResponseValue;
8779 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
8781 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: bigint): bigint {
8782 if(!isWasmInitialized) {
8783 throw new Error("initializeWasm() must be awaited first!");
8785 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
8786 return nativeResponseValue;
8789 export class LDKBolt11ParseError {
8790 protected constructor() {}
8793 export function LDKBolt11ParseError_ty_from_ptr(ptr: bigint): number {
8794 if(!isWasmInitialized) {
8795 throw new Error("initializeWasm() must be awaited first!");
8797 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_ty_from_ptr(ptr);
8798 return nativeResponseValue;
8801 export function LDKBolt11ParseError_Bech32Error_get_bech32_error(ptr: bigint): bigint {
8802 if(!isWasmInitialized) {
8803 throw new Error("initializeWasm() must be awaited first!");
8805 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_Bech32Error_get_bech32_error(ptr);
8806 return nativeResponseValue;
8809 export function LDKBolt11ParseError_ParseAmountError_get_parse_amount_error(ptr: bigint): number {
8810 if(!isWasmInitialized) {
8811 throw new Error("initializeWasm() must be awaited first!");
8813 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_ParseAmountError_get_parse_amount_error(ptr);
8814 return nativeResponseValue;
8817 export function LDKBolt11ParseError_MalformedSignature_get_malformed_signature(ptr: bigint): Secp256k1Error {
8818 if(!isWasmInitialized) {
8819 throw new Error("initializeWasm() must be awaited first!");
8821 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_MalformedSignature_get_malformed_signature(ptr);
8822 return nativeResponseValue;
8825 export function LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error(ptr: bigint): number {
8826 if(!isWasmInitialized) {
8827 throw new Error("initializeWasm() must be awaited first!");
8829 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error(ptr);
8830 return nativeResponseValue;
8833 export function LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length(ptr: bigint): number {
8834 if(!isWasmInitialized) {
8835 throw new Error("initializeWasm() must be awaited first!");
8837 const nativeResponseValue = wasm.TS_LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
8838 return nativeResponseValue;
8840 // enum LDKSiPrefix CResult_SiPrefixBolt11ParseErrorZ_get_ok(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
8842 export function CResult_SiPrefixBolt11ParseErrorZ_get_ok(owner: bigint): SiPrefix {
8843 if(!isWasmInitialized) {
8844 throw new Error("initializeWasm() must be awaited first!");
8846 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_get_ok(owner);
8847 return nativeResponseValue;
8849 // struct LDKBolt11ParseError CResult_SiPrefixBolt11ParseErrorZ_get_err(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
8851 export function CResult_SiPrefixBolt11ParseErrorZ_get_err(owner: bigint): bigint {
8852 if(!isWasmInitialized) {
8853 throw new Error("initializeWasm() must be awaited first!");
8855 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_get_err(owner);
8856 return nativeResponseValue;
8859 export class LDKParseOrSemanticError {
8860 protected constructor() {}
8863 export function LDKParseOrSemanticError_ty_from_ptr(ptr: bigint): number {
8864 if(!isWasmInitialized) {
8865 throw new Error("initializeWasm() must be awaited first!");
8867 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
8868 return nativeResponseValue;
8871 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: bigint): bigint {
8872 if(!isWasmInitialized) {
8873 throw new Error("initializeWasm() must be awaited first!");
8875 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
8876 return nativeResponseValue;
8879 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: bigint): Bolt11SemanticError {
8880 if(!isWasmInitialized) {
8881 throw new Error("initializeWasm() must be awaited first!");
8883 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
8884 return nativeResponseValue;
8886 // struct LDKBolt11Invoice CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
8888 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(owner: bigint): bigint {
8889 if(!isWasmInitialized) {
8890 throw new Error("initializeWasm() must be awaited first!");
8892 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(owner);
8893 return nativeResponseValue;
8895 // struct LDKParseOrSemanticError CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
8897 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(owner: bigint): bigint {
8898 if(!isWasmInitialized) {
8899 throw new Error("initializeWasm() must be awaited first!");
8901 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(owner);
8902 return nativeResponseValue;
8904 // struct LDKSignedRawBolt11Invoice CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
8906 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(owner: bigint): bigint {
8907 if(!isWasmInitialized) {
8908 throw new Error("initializeWasm() must be awaited first!");
8910 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(owner);
8911 return nativeResponseValue;
8913 // struct LDKBolt11ParseError CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
8915 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(owner: bigint): bigint {
8916 if(!isWasmInitialized) {
8917 throw new Error("initializeWasm() must be awaited first!");
8919 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(owner);
8920 return nativeResponseValue;
8922 // struct LDKRawBolt11Invoice C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8924 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(owner: bigint): bigint {
8925 if(!isWasmInitialized) {
8926 throw new Error("initializeWasm() must be awaited first!");
8928 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(owner);
8929 return nativeResponseValue;
8931 // struct LDKThirtyTwoBytes C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8933 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(owner: bigint): number {
8934 if(!isWasmInitialized) {
8935 throw new Error("initializeWasm() must be awaited first!");
8937 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(owner);
8938 return nativeResponseValue;
8940 // struct LDKBolt11InvoiceSignature C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
8942 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(owner: bigint): bigint {
8943 if(!isWasmInitialized) {
8944 throw new Error("initializeWasm() must be awaited first!");
8946 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(owner);
8947 return nativeResponseValue;
8949 // struct LDKPayeePubKey CResult_PayeePubKeySecp256k1ErrorZ_get_ok(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner);
8951 export function CResult_PayeePubKeySecp256k1ErrorZ_get_ok(owner: bigint): bigint {
8952 if(!isWasmInitialized) {
8953 throw new Error("initializeWasm() must be awaited first!");
8955 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_get_ok(owner);
8956 return nativeResponseValue;
8958 // enum LDKSecp256k1Error CResult_PayeePubKeySecp256k1ErrorZ_get_err(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner);
8960 export function CResult_PayeePubKeySecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
8961 if(!isWasmInitialized) {
8962 throw new Error("initializeWasm() must be awaited first!");
8964 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_get_err(owner);
8965 return nativeResponseValue;
8967 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
8969 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: bigint): bigint {
8970 if(!isWasmInitialized) {
8971 throw new Error("initializeWasm() must be awaited first!");
8973 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
8974 return nativeResponseValue;
8976 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
8978 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: bigint): CreationError {
8979 if(!isWasmInitialized) {
8980 throw new Error("initializeWasm() must be awaited first!");
8982 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
8983 return nativeResponseValue;
8985 // void CResult_NoneBolt11SemanticErrorZ_get_ok(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
8987 export function CResult_NoneBolt11SemanticErrorZ_get_ok(owner: bigint): void {
8988 if(!isWasmInitialized) {
8989 throw new Error("initializeWasm() must be awaited first!");
8991 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_get_ok(owner);
8992 // debug statements here
8994 // enum LDKBolt11SemanticError CResult_NoneBolt11SemanticErrorZ_get_err(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
8996 export function CResult_NoneBolt11SemanticErrorZ_get_err(owner: bigint): Bolt11SemanticError {
8997 if(!isWasmInitialized) {
8998 throw new Error("initializeWasm() must be awaited first!");
9000 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_get_err(owner);
9001 return nativeResponseValue;
9003 // struct LDKBolt11Invoice CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
9005 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(owner: bigint): bigint {
9006 if(!isWasmInitialized) {
9007 throw new Error("initializeWasm() must be awaited first!");
9009 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(owner);
9010 return nativeResponseValue;
9012 // enum LDKBolt11SemanticError CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
9014 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(owner: bigint): Bolt11SemanticError {
9015 if(!isWasmInitialized) {
9016 throw new Error("initializeWasm() must be awaited first!");
9018 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(owner);
9019 return nativeResponseValue;
9021 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
9023 export function CResult_DescriptionCreationErrorZ_get_ok(owner: bigint): bigint {
9024 if(!isWasmInitialized) {
9025 throw new Error("initializeWasm() must be awaited first!");
9027 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
9028 return nativeResponseValue;
9030 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
9032 export function CResult_DescriptionCreationErrorZ_get_err(owner: bigint): CreationError {
9033 if(!isWasmInitialized) {
9034 throw new Error("initializeWasm() must be awaited first!");
9036 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
9037 return nativeResponseValue;
9039 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
9041 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: bigint): bigint {
9042 if(!isWasmInitialized) {
9043 throw new Error("initializeWasm() must be awaited first!");
9045 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
9046 return nativeResponseValue;
9048 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
9050 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: bigint): CreationError {
9051 if(!isWasmInitialized) {
9052 throw new Error("initializeWasm() must be awaited first!");
9054 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
9055 return nativeResponseValue;
9057 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
9059 export function CResult_OutPointDecodeErrorZ_get_ok(owner: bigint): bigint {
9060 if(!isWasmInitialized) {
9061 throw new Error("initializeWasm() must be awaited first!");
9063 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
9064 return nativeResponseValue;
9066 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
9068 export function CResult_OutPointDecodeErrorZ_get_err(owner: bigint): bigint {
9069 if(!isWasmInitialized) {
9070 throw new Error("initializeWasm() must be awaited first!");
9072 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
9073 return nativeResponseValue;
9075 // struct LDKBigSize CResult_BigSizeDecodeErrorZ_get_ok(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
9077 export function CResult_BigSizeDecodeErrorZ_get_ok(owner: bigint): bigint {
9078 if(!isWasmInitialized) {
9079 throw new Error("initializeWasm() must be awaited first!");
9081 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_get_ok(owner);
9082 return nativeResponseValue;
9084 // struct LDKDecodeError CResult_BigSizeDecodeErrorZ_get_err(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
9086 export function CResult_BigSizeDecodeErrorZ_get_err(owner: bigint): bigint {
9087 if(!isWasmInitialized) {
9088 throw new Error("initializeWasm() must be awaited first!");
9090 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_get_err(owner);
9091 return nativeResponseValue;
9093 // struct LDKHostname CResult_HostnameDecodeErrorZ_get_ok(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
9095 export function CResult_HostnameDecodeErrorZ_get_ok(owner: bigint): bigint {
9096 if(!isWasmInitialized) {
9097 throw new Error("initializeWasm() must be awaited first!");
9099 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_get_ok(owner);
9100 return nativeResponseValue;
9102 // struct LDKDecodeError CResult_HostnameDecodeErrorZ_get_err(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
9104 export function CResult_HostnameDecodeErrorZ_get_err(owner: bigint): bigint {
9105 if(!isWasmInitialized) {
9106 throw new Error("initializeWasm() must be awaited first!");
9108 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_get_err(owner);
9109 return nativeResponseValue;
9111 // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedNoneZ_get_ok(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
9113 export function CResult_TransactionU16LenLimitedNoneZ_get_ok(owner: bigint): bigint {
9114 if(!isWasmInitialized) {
9115 throw new Error("initializeWasm() must be awaited first!");
9117 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_get_ok(owner);
9118 return nativeResponseValue;
9120 // void CResult_TransactionU16LenLimitedNoneZ_get_err(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
9122 export function CResult_TransactionU16LenLimitedNoneZ_get_err(owner: bigint): void {
9123 if(!isWasmInitialized) {
9124 throw new Error("initializeWasm() must be awaited first!");
9126 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_get_err(owner);
9127 // debug statements here
9129 // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
9131 export function CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(owner: bigint): bigint {
9132 if(!isWasmInitialized) {
9133 throw new Error("initializeWasm() must be awaited first!");
9135 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(owner);
9136 return nativeResponseValue;
9138 // struct LDKDecodeError CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
9140 export function CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(owner: bigint): bigint {
9141 if(!isWasmInitialized) {
9142 throw new Error("initializeWasm() must be awaited first!");
9144 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(owner);
9145 return nativeResponseValue;
9147 // struct LDKUntrustedString CResult_UntrustedStringDecodeErrorZ_get_ok(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
9149 export function CResult_UntrustedStringDecodeErrorZ_get_ok(owner: bigint): bigint {
9150 if(!isWasmInitialized) {
9151 throw new Error("initializeWasm() must be awaited first!");
9153 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_ok(owner);
9154 return nativeResponseValue;
9156 // struct LDKDecodeError CResult_UntrustedStringDecodeErrorZ_get_err(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
9158 export function CResult_UntrustedStringDecodeErrorZ_get_err(owner: bigint): bigint {
9159 if(!isWasmInitialized) {
9160 throw new Error("initializeWasm() must be awaited first!");
9162 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_get_err(owner);
9163 return nativeResponseValue;
9165 // struct LDKThirtyTwoBytes C2Tuple__u832u16Z_get_a(LDKC2Tuple__u832u16Z *NONNULL_PTR owner);
9167 export function C2Tuple__u832u16Z_get_a(owner: bigint): number {
9168 if(!isWasmInitialized) {
9169 throw new Error("initializeWasm() must be awaited first!");
9171 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_get_a(owner);
9172 return nativeResponseValue;
9174 // uint16_t C2Tuple__u832u16Z_get_b(LDKC2Tuple__u832u16Z *NONNULL_PTR owner);
9176 export function C2Tuple__u832u16Z_get_b(owner: bigint): number {
9177 if(!isWasmInitialized) {
9178 throw new Error("initializeWasm() must be awaited first!");
9180 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_get_b(owner);
9181 return nativeResponseValue;
9183 // struct LDKPaymentRelay CResult_PaymentRelayDecodeErrorZ_get_ok(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner);
9185 export function CResult_PaymentRelayDecodeErrorZ_get_ok(owner: bigint): bigint {
9186 if(!isWasmInitialized) {
9187 throw new Error("initializeWasm() must be awaited first!");
9189 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_get_ok(owner);
9190 return nativeResponseValue;
9192 // struct LDKDecodeError CResult_PaymentRelayDecodeErrorZ_get_err(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner);
9194 export function CResult_PaymentRelayDecodeErrorZ_get_err(owner: bigint): bigint {
9195 if(!isWasmInitialized) {
9196 throw new Error("initializeWasm() must be awaited first!");
9198 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_get_err(owner);
9199 return nativeResponseValue;
9201 // struct LDKPaymentConstraints CResult_PaymentConstraintsDecodeErrorZ_get_ok(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner);
9203 export function CResult_PaymentConstraintsDecodeErrorZ_get_ok(owner: bigint): bigint {
9204 if(!isWasmInitialized) {
9205 throw new Error("initializeWasm() must be awaited first!");
9207 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_get_ok(owner);
9208 return nativeResponseValue;
9210 // struct LDKDecodeError CResult_PaymentConstraintsDecodeErrorZ_get_err(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner);
9212 export function CResult_PaymentConstraintsDecodeErrorZ_get_err(owner: bigint): bigint {
9213 if(!isWasmInitialized) {
9214 throw new Error("initializeWasm() must be awaited first!");
9216 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_get_err(owner);
9217 return nativeResponseValue;
9219 // struct LDKThirtyTwoBytes C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_a(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR owner);
9221 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_a(owner: bigint): number {
9222 if(!isWasmInitialized) {
9223 throw new Error("initializeWasm() must be awaited first!");
9225 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_a(owner);
9226 return nativeResponseValue;
9228 // struct LDKRecipientOnionFields C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_b(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR owner);
9230 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_b(owner: bigint): bigint {
9231 if(!isWasmInitialized) {
9232 throw new Error("initializeWasm() must be awaited first!");
9234 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_b(owner);
9235 return nativeResponseValue;
9237 // struct LDKRouteParameters C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_c(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR owner);
9239 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_c(owner: bigint): bigint {
9240 if(!isWasmInitialized) {
9241 throw new Error("initializeWasm() must be awaited first!");
9243 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_c(owner);
9244 return nativeResponseValue;
9246 // struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_ok(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR owner);
9248 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_ok(owner: bigint): bigint {
9249 if(!isWasmInitialized) {
9250 throw new Error("initializeWasm() must be awaited first!");
9252 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_ok(owner);
9253 return nativeResponseValue;
9255 // void CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_err(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR owner);
9257 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_err(owner: bigint): void {
9258 if(!isWasmInitialized) {
9259 throw new Error("initializeWasm() must be awaited first!");
9261 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_err(owner);
9262 // debug statements here
9264 // struct LDKStr CResult_StrSecp256k1ErrorZ_get_ok(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner);
9266 export function CResult_StrSecp256k1ErrorZ_get_ok(owner: bigint): number {
9267 if(!isWasmInitialized) {
9268 throw new Error("initializeWasm() must be awaited first!");
9270 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_get_ok(owner);
9271 return nativeResponseValue;
9273 // enum LDKSecp256k1Error CResult_StrSecp256k1ErrorZ_get_err(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner);
9275 export function CResult_StrSecp256k1ErrorZ_get_err(owner: bigint): Secp256k1Error {
9276 if(!isWasmInitialized) {
9277 throw new Error("initializeWasm() must be awaited first!");
9279 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_get_err(owner);
9280 return nativeResponseValue;
9282 // struct LDKPublicKey C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_a(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR owner);
9284 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_a(owner: bigint): number {
9285 if(!isWasmInitialized) {
9286 throw new Error("initializeWasm() must be awaited first!");
9288 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_a(owner);
9289 return nativeResponseValue;
9291 // struct LDKOnionMessage C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_b(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR owner);
9293 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_b(owner: bigint): bigint {
9294 if(!isWasmInitialized) {
9295 throw new Error("initializeWasm() must be awaited first!");
9297 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_b(owner);
9298 return nativeResponseValue;
9300 // struct LDKCOption_CVec_SocketAddressZZ C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_c(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR owner);
9302 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_c(owner: bigint): bigint {
9303 if(!isWasmInitialized) {
9304 throw new Error("initializeWasm() must be awaited first!");
9306 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_c(owner);
9307 return nativeResponseValue;
9310 export class LDKSendError {
9311 protected constructor() {}
9314 export function LDKSendError_ty_from_ptr(ptr: bigint): number {
9315 if(!isWasmInitialized) {
9316 throw new Error("initializeWasm() must be awaited first!");
9318 const nativeResponseValue = wasm.TS_LDKSendError_ty_from_ptr(ptr);
9319 return nativeResponseValue;
9322 export function LDKSendError_Secp256k1_get_secp256k1(ptr: bigint): Secp256k1Error {
9323 if(!isWasmInitialized) {
9324 throw new Error("initializeWasm() must be awaited first!");
9326 const nativeResponseValue = wasm.TS_LDKSendError_Secp256k1_get_secp256k1(ptr);
9327 return nativeResponseValue;
9330 export function LDKSendError_InvalidFirstHop_get_invalid_first_hop(ptr: bigint): number {
9331 if(!isWasmInitialized) {
9332 throw new Error("initializeWasm() must be awaited first!");
9334 const nativeResponseValue = wasm.TS_LDKSendError_InvalidFirstHop_get_invalid_first_hop(ptr);
9335 return nativeResponseValue;
9337 // struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_ok(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ *NONNULL_PTR owner);
9339 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_ok(owner: bigint): bigint {
9340 if(!isWasmInitialized) {
9341 throw new Error("initializeWasm() must be awaited first!");
9343 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_ok(owner);
9344 return nativeResponseValue;
9346 // struct LDKSendError CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_err(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ *NONNULL_PTR owner);
9348 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_err(owner: bigint): bigint {
9349 if(!isWasmInitialized) {
9350 throw new Error("initializeWasm() must be awaited first!");
9352 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_err(owner);
9353 return nativeResponseValue;
9356 export class LDKParsedOnionMessageContents {
9357 protected constructor() {}
9360 export function LDKParsedOnionMessageContents_ty_from_ptr(ptr: bigint): number {
9361 if(!isWasmInitialized) {
9362 throw new Error("initializeWasm() must be awaited first!");
9364 const nativeResponseValue = wasm.TS_LDKParsedOnionMessageContents_ty_from_ptr(ptr);
9365 return nativeResponseValue;
9368 export function LDKParsedOnionMessageContents_Offers_get_offers(ptr: bigint): bigint {
9369 if(!isWasmInitialized) {
9370 throw new Error("initializeWasm() must be awaited first!");
9372 const nativeResponseValue = wasm.TS_LDKParsedOnionMessageContents_Offers_get_offers(ptr);
9373 return nativeResponseValue;
9376 export function LDKParsedOnionMessageContents_Custom_get_custom(ptr: bigint): bigint {
9377 if(!isWasmInitialized) {
9378 throw new Error("initializeWasm() must be awaited first!");
9380 const nativeResponseValue = wasm.TS_LDKParsedOnionMessageContents_Custom_get_custom(ptr);
9381 return nativeResponseValue;
9384 export class LDKPeeledOnion {
9385 protected constructor() {}
9388 export function LDKPeeledOnion_ty_from_ptr(ptr: bigint): number {
9389 if(!isWasmInitialized) {
9390 throw new Error("initializeWasm() must be awaited first!");
9392 const nativeResponseValue = wasm.TS_LDKPeeledOnion_ty_from_ptr(ptr);
9393 return nativeResponseValue;
9396 export function LDKPeeledOnion_Forward_get__0(ptr: bigint): number {
9397 if(!isWasmInitialized) {
9398 throw new Error("initializeWasm() must be awaited first!");
9400 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Forward_get__0(ptr);
9401 return nativeResponseValue;
9404 export function LDKPeeledOnion_Forward_get__1(ptr: bigint): bigint {
9405 if(!isWasmInitialized) {
9406 throw new Error("initializeWasm() must be awaited first!");
9408 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Forward_get__1(ptr);
9409 return nativeResponseValue;
9412 export function LDKPeeledOnion_Receive_get__0(ptr: bigint): bigint {
9413 if(!isWasmInitialized) {
9414 throw new Error("initializeWasm() must be awaited first!");
9416 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Receive_get__0(ptr);
9417 return nativeResponseValue;
9420 export function LDKPeeledOnion_Receive_get__1(ptr: bigint): number {
9421 if(!isWasmInitialized) {
9422 throw new Error("initializeWasm() must be awaited first!");
9424 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Receive_get__1(ptr);
9425 return nativeResponseValue;
9428 export function LDKPeeledOnion_Receive_get__2(ptr: bigint): bigint {
9429 if(!isWasmInitialized) {
9430 throw new Error("initializeWasm() must be awaited first!");
9432 const nativeResponseValue = wasm.TS_LDKPeeledOnion_Receive_get__2(ptr);
9433 return nativeResponseValue;
9435 // struct LDKPeeledOnion CResult_PeeledOnionNoneZ_get_ok(LDKCResult_PeeledOnionNoneZ *NONNULL_PTR owner);
9437 export function CResult_PeeledOnionNoneZ_get_ok(owner: bigint): bigint {
9438 if(!isWasmInitialized) {
9439 throw new Error("initializeWasm() must be awaited first!");
9441 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_get_ok(owner);
9442 return nativeResponseValue;
9444 // void CResult_PeeledOnionNoneZ_get_err(LDKCResult_PeeledOnionNoneZ *NONNULL_PTR owner);
9446 export function CResult_PeeledOnionNoneZ_get_err(owner: bigint): void {
9447 if(!isWasmInitialized) {
9448 throw new Error("initializeWasm() must be awaited first!");
9450 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_get_err(owner);
9451 // debug statements here
9454 export class LDKSendSuccess {
9455 protected constructor() {}
9458 export function LDKSendSuccess_ty_from_ptr(ptr: bigint): number {
9459 if(!isWasmInitialized) {
9460 throw new Error("initializeWasm() must be awaited first!");
9462 const nativeResponseValue = wasm.TS_LDKSendSuccess_ty_from_ptr(ptr);
9463 return nativeResponseValue;
9466 export function LDKSendSuccess_BufferedAwaitingConnection_get_buffered_awaiting_connection(ptr: bigint): number {
9467 if(!isWasmInitialized) {
9468 throw new Error("initializeWasm() must be awaited first!");
9470 const nativeResponseValue = wasm.TS_LDKSendSuccess_BufferedAwaitingConnection_get_buffered_awaiting_connection(ptr);
9471 return nativeResponseValue;
9473 // struct LDKSendSuccess CResult_SendSuccessSendErrorZ_get_ok(LDKCResult_SendSuccessSendErrorZ *NONNULL_PTR owner);
9475 export function CResult_SendSuccessSendErrorZ_get_ok(owner: bigint): bigint {
9476 if(!isWasmInitialized) {
9477 throw new Error("initializeWasm() must be awaited first!");
9479 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_get_ok(owner);
9480 return nativeResponseValue;
9482 // struct LDKSendError CResult_SendSuccessSendErrorZ_get_err(LDKCResult_SendSuccessSendErrorZ *NONNULL_PTR owner);
9484 export function CResult_SendSuccessSendErrorZ_get_err(owner: bigint): bigint {
9485 if(!isWasmInitialized) {
9486 throw new Error("initializeWasm() must be awaited first!");
9488 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_get_err(owner);
9489 return nativeResponseValue;
9491 // struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
9493 export function CResult_BlindedPathNoneZ_get_ok(owner: bigint): bigint {
9494 if(!isWasmInitialized) {
9495 throw new Error("initializeWasm() must be awaited first!");
9497 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_ok(owner);
9498 return nativeResponseValue;
9500 // void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
9502 export function CResult_BlindedPathNoneZ_get_err(owner: bigint): void {
9503 if(!isWasmInitialized) {
9504 throw new Error("initializeWasm() must be awaited first!");
9506 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_get_err(owner);
9507 // debug statements here
9509 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner);
9511 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(owner: bigint): bigint {
9512 if(!isWasmInitialized) {
9513 throw new Error("initializeWasm() must be awaited first!");
9515 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(owner);
9516 return nativeResponseValue;
9518 // void CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner);
9520 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(owner: bigint): void {
9521 if(!isWasmInitialized) {
9522 throw new Error("initializeWasm() must be awaited first!");
9524 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(owner);
9525 // debug statements here
9527 // struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
9529 export function CResult_BlindedPathDecodeErrorZ_get_ok(owner: bigint): bigint {
9530 if(!isWasmInitialized) {
9531 throw new Error("initializeWasm() must be awaited first!");
9533 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_ok(owner);
9534 return nativeResponseValue;
9536 // struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
9538 export function CResult_BlindedPathDecodeErrorZ_get_err(owner: bigint): bigint {
9539 if(!isWasmInitialized) {
9540 throw new Error("initializeWasm() must be awaited first!");
9542 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_get_err(owner);
9543 return nativeResponseValue;
9545 // struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
9547 export function CResult_BlindedHopDecodeErrorZ_get_ok(owner: bigint): bigint {
9548 if(!isWasmInitialized) {
9549 throw new Error("initializeWasm() must be awaited first!");
9551 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_ok(owner);
9552 return nativeResponseValue;
9554 // struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
9556 export function CResult_BlindedHopDecodeErrorZ_get_err(owner: bigint): bigint {
9557 if(!isWasmInitialized) {
9558 throw new Error("initializeWasm() must be awaited first!");
9560 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_get_err(owner);
9561 return nativeResponseValue;
9563 // struct LDKInvoiceError CResult_InvoiceErrorDecodeErrorZ_get_ok(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
9565 export function CResult_InvoiceErrorDecodeErrorZ_get_ok(owner: bigint): bigint {
9566 if(!isWasmInitialized) {
9567 throw new Error("initializeWasm() must be awaited first!");
9569 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_get_ok(owner);
9570 return nativeResponseValue;
9572 // struct LDKDecodeError CResult_InvoiceErrorDecodeErrorZ_get_err(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
9574 export function CResult_InvoiceErrorDecodeErrorZ_get_err(owner: bigint): bigint {
9575 if(!isWasmInitialized) {
9576 throw new Error("initializeWasm() must be awaited first!");
9578 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_get_err(owner);
9579 return nativeResponseValue;
9581 // struct LDKDelayedPaymentBasepoint CResult_DelayedPaymentBasepointDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR owner);
9583 export function CResult_DelayedPaymentBasepointDecodeErrorZ_get_ok(owner: bigint): bigint {
9584 if(!isWasmInitialized) {
9585 throw new Error("initializeWasm() must be awaited first!");
9587 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_get_ok(owner);
9588 return nativeResponseValue;
9590 // struct LDKDecodeError CResult_DelayedPaymentBasepointDecodeErrorZ_get_err(LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR owner);
9592 export function CResult_DelayedPaymentBasepointDecodeErrorZ_get_err(owner: bigint): bigint {
9593 if(!isWasmInitialized) {
9594 throw new Error("initializeWasm() must be awaited first!");
9596 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_get_err(owner);
9597 return nativeResponseValue;
9599 // struct LDKDelayedPaymentKey CResult_DelayedPaymentKeyDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR owner);
9601 export function CResult_DelayedPaymentKeyDecodeErrorZ_get_ok(owner: bigint): bigint {
9602 if(!isWasmInitialized) {
9603 throw new Error("initializeWasm() must be awaited first!");
9605 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_get_ok(owner);
9606 return nativeResponseValue;
9608 // struct LDKDecodeError CResult_DelayedPaymentKeyDecodeErrorZ_get_err(LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR owner);
9610 export function CResult_DelayedPaymentKeyDecodeErrorZ_get_err(owner: bigint): bigint {
9611 if(!isWasmInitialized) {
9612 throw new Error("initializeWasm() must be awaited first!");
9614 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_get_err(owner);
9615 return nativeResponseValue;
9617 // struct LDKHtlcBasepoint CResult_HtlcBasepointDecodeErrorZ_get_ok(LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR owner);
9619 export function CResult_HtlcBasepointDecodeErrorZ_get_ok(owner: bigint): bigint {
9620 if(!isWasmInitialized) {
9621 throw new Error("initializeWasm() must be awaited first!");
9623 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_get_ok(owner);
9624 return nativeResponseValue;
9626 // struct LDKDecodeError CResult_HtlcBasepointDecodeErrorZ_get_err(LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR owner);
9628 export function CResult_HtlcBasepointDecodeErrorZ_get_err(owner: bigint): bigint {
9629 if(!isWasmInitialized) {
9630 throw new Error("initializeWasm() must be awaited first!");
9632 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_get_err(owner);
9633 return nativeResponseValue;
9635 // struct LDKHtlcKey CResult_HtlcKeyDecodeErrorZ_get_ok(LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR owner);
9637 export function CResult_HtlcKeyDecodeErrorZ_get_ok(owner: bigint): bigint {
9638 if(!isWasmInitialized) {
9639 throw new Error("initializeWasm() must be awaited first!");
9641 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_get_ok(owner);
9642 return nativeResponseValue;
9644 // struct LDKDecodeError CResult_HtlcKeyDecodeErrorZ_get_err(LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR owner);
9646 export function CResult_HtlcKeyDecodeErrorZ_get_err(owner: bigint): bigint {
9647 if(!isWasmInitialized) {
9648 throw new Error("initializeWasm() must be awaited first!");
9650 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_get_err(owner);
9651 return nativeResponseValue;
9653 // struct LDKRevocationBasepoint CResult_RevocationBasepointDecodeErrorZ_get_ok(LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR owner);
9655 export function CResult_RevocationBasepointDecodeErrorZ_get_ok(owner: bigint): bigint {
9656 if(!isWasmInitialized) {
9657 throw new Error("initializeWasm() must be awaited first!");
9659 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_get_ok(owner);
9660 return nativeResponseValue;
9662 // struct LDKDecodeError CResult_RevocationBasepointDecodeErrorZ_get_err(LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR owner);
9664 export function CResult_RevocationBasepointDecodeErrorZ_get_err(owner: bigint): bigint {
9665 if(!isWasmInitialized) {
9666 throw new Error("initializeWasm() must be awaited first!");
9668 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_get_err(owner);
9669 return nativeResponseValue;
9671 // struct LDKRevocationKey CResult_RevocationKeyDecodeErrorZ_get_ok(LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR owner);
9673 export function CResult_RevocationKeyDecodeErrorZ_get_ok(owner: bigint): bigint {
9674 if(!isWasmInitialized) {
9675 throw new Error("initializeWasm() must be awaited first!");
9677 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_get_ok(owner);
9678 return nativeResponseValue;
9680 // struct LDKDecodeError CResult_RevocationKeyDecodeErrorZ_get_err(LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR owner);
9682 export function CResult_RevocationKeyDecodeErrorZ_get_err(owner: bigint): bigint {
9683 if(!isWasmInitialized) {
9684 throw new Error("initializeWasm() must be awaited first!");
9686 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_get_err(owner);
9687 return nativeResponseValue;
9690 export interface LDKFilter {
9691 register_tx (txid: number, script_pubkey: number): void;
9692 register_output (output: bigint): void;
9696 export function LDKFilter_new(impl: LDKFilter): [bigint, number] {
9697 if(!isWasmInitialized) {
9698 throw new Error("initializeWasm() must be awaited first!");
9700 var new_obj_idx = js_objs.length;
9701 for (var i = 0; i < js_objs.length; i++) {
9702 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9704 js_objs[i] = new WeakRef(impl);
9705 return [wasm.TS_LDKFilter_new(i), i];
9707 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
9709 export function Filter_register_tx(this_arg: bigint, txid: number, script_pubkey: number): void {
9710 if(!isWasmInitialized) {
9711 throw new Error("initializeWasm() must be awaited first!");
9713 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
9714 // debug statements here
9716 // void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
9718 export function Filter_register_output(this_arg: bigint, output: bigint): void {
9719 if(!isWasmInitialized) {
9720 throw new Error("initializeWasm() must be awaited first!");
9722 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
9723 // debug statements here
9726 export class LDKCOption_FilterZ {
9727 protected constructor() {}
9730 export function LDKCOption_FilterZ_ty_from_ptr(ptr: bigint): number {
9731 if(!isWasmInitialized) {
9732 throw new Error("initializeWasm() must be awaited first!");
9734 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
9735 return nativeResponseValue;
9738 export function LDKCOption_FilterZ_Some_get_some(ptr: bigint): bigint {
9739 if(!isWasmInitialized) {
9740 throw new Error("initializeWasm() must be awaited first!");
9742 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
9743 return nativeResponseValue;
9745 // struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
9747 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: bigint): bigint {
9748 if(!isWasmInitialized) {
9749 throw new Error("initializeWasm() must be awaited first!");
9751 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
9752 return nativeResponseValue;
9754 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
9756 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: bigint): void {
9757 if(!isWasmInitialized) {
9758 throw new Error("initializeWasm() must be awaited first!");
9760 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
9761 // debug statements here
9763 // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
9765 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner: bigint): bigint {
9766 if(!isWasmInitialized) {
9767 throw new Error("initializeWasm() must be awaited first!");
9769 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner);
9770 return nativeResponseValue;
9772 // struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
9774 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner: bigint): number {
9775 if(!isWasmInitialized) {
9776 throw new Error("initializeWasm() must be awaited first!");
9778 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner);
9779 return nativeResponseValue;
9782 export interface LDKKVStore {
9783 read (primary_namespace: number, secondary_namespace: number, key: number): bigint;
9784 write (primary_namespace: number, secondary_namespace: number, key: number, buf: number): bigint;
9785 remove (primary_namespace: number, secondary_namespace: number, key: number, lazy: boolean): bigint;
9786 list (primary_namespace: number, secondary_namespace: number): bigint;
9790 export function LDKKVStore_new(impl: LDKKVStore): [bigint, number] {
9791 if(!isWasmInitialized) {
9792 throw new Error("initializeWasm() must be awaited first!");
9794 var new_obj_idx = js_objs.length;
9795 for (var i = 0; i < js_objs.length; i++) {
9796 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9798 js_objs[i] = new WeakRef(impl);
9799 return [wasm.TS_LDKKVStore_new(i), i];
9801 // LDKCResult_CVec_u8ZIOErrorZ KVStore_read LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key
9803 export function KVStore_read(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number): bigint {
9804 if(!isWasmInitialized) {
9805 throw new Error("initializeWasm() must be awaited first!");
9807 const nativeResponseValue = wasm.TS_KVStore_read(this_arg, primary_namespace, secondary_namespace, key);
9808 return nativeResponseValue;
9810 // LDKCResult_NoneIOErrorZ KVStore_write LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf
9812 export function KVStore_write(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number, buf: number): bigint {
9813 if(!isWasmInitialized) {
9814 throw new Error("initializeWasm() must be awaited first!");
9816 const nativeResponseValue = wasm.TS_KVStore_write(this_arg, primary_namespace, secondary_namespace, key, buf);
9817 return nativeResponseValue;
9819 // LDKCResult_NoneIOErrorZ KVStore_remove LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy
9821 export function KVStore_remove(this_arg: bigint, primary_namespace: number, secondary_namespace: number, key: number, lazy: boolean): bigint {
9822 if(!isWasmInitialized) {
9823 throw new Error("initializeWasm() must be awaited first!");
9825 const nativeResponseValue = wasm.TS_KVStore_remove(this_arg, primary_namespace, secondary_namespace, key, lazy);
9826 return nativeResponseValue;
9828 // LDKCResult_CVec_StrZIOErrorZ KVStore_list LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace
9830 export function KVStore_list(this_arg: bigint, primary_namespace: number, secondary_namespace: number): bigint {
9831 if(!isWasmInitialized) {
9832 throw new Error("initializeWasm() must be awaited first!");
9834 const nativeResponseValue = wasm.TS_KVStore_list(this_arg, primary_namespace, secondary_namespace);
9835 return nativeResponseValue;
9838 export class LDKCandidateRouteHop {
9839 protected constructor() {}
9842 export function LDKCandidateRouteHop_ty_from_ptr(ptr: bigint): number {
9843 if(!isWasmInitialized) {
9844 throw new Error("initializeWasm() must be awaited first!");
9846 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_ty_from_ptr(ptr);
9847 return nativeResponseValue;
9850 export function LDKCandidateRouteHop_FirstHop_get_first_hop(ptr: bigint): bigint {
9851 if(!isWasmInitialized) {
9852 throw new Error("initializeWasm() must be awaited first!");
9854 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_FirstHop_get_first_hop(ptr);
9855 return nativeResponseValue;
9858 export function LDKCandidateRouteHop_PublicHop_get_public_hop(ptr: bigint): bigint {
9859 if(!isWasmInitialized) {
9860 throw new Error("initializeWasm() must be awaited first!");
9862 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_PublicHop_get_public_hop(ptr);
9863 return nativeResponseValue;
9866 export function LDKCandidateRouteHop_PrivateHop_get_private_hop(ptr: bigint): bigint {
9867 if(!isWasmInitialized) {
9868 throw new Error("initializeWasm() must be awaited first!");
9870 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_PrivateHop_get_private_hop(ptr);
9871 return nativeResponseValue;
9874 export function LDKCandidateRouteHop_Blinded_get_blinded(ptr: bigint): bigint {
9875 if(!isWasmInitialized) {
9876 throw new Error("initializeWasm() must be awaited first!");
9878 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_Blinded_get_blinded(ptr);
9879 return nativeResponseValue;
9882 export function LDKCandidateRouteHop_OneHopBlinded_get_one_hop_blinded(ptr: bigint): bigint {
9883 if(!isWasmInitialized) {
9884 throw new Error("initializeWasm() must be awaited first!");
9886 const nativeResponseValue = wasm.TS_LDKCandidateRouteHop_OneHopBlinded_get_one_hop_blinded(ptr);
9887 return nativeResponseValue;
9890 export interface LDKScoreLookUp {
9891 channel_penalty_msat (candidate: bigint, usage: bigint, score_params: bigint): bigint;
9895 export function LDKScoreLookUp_new(impl: LDKScoreLookUp): [bigint, number] {
9896 if(!isWasmInitialized) {
9897 throw new Error("initializeWasm() must be awaited first!");
9899 var new_obj_idx = js_objs.length;
9900 for (var i = 0; i < js_objs.length; i++) {
9901 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9903 js_objs[i] = new WeakRef(impl);
9904 return [wasm.TS_LDKScoreLookUp_new(i), i];
9906 // uint64_t ScoreLookUp_channel_penalty_msat LDKScoreLookUp *NONNULL_PTR this_arg, const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params
9908 export function ScoreLookUp_channel_penalty_msat(this_arg: bigint, candidate: bigint, usage: bigint, score_params: bigint): bigint {
9909 if(!isWasmInitialized) {
9910 throw new Error("initializeWasm() must be awaited first!");
9912 const nativeResponseValue = wasm.TS_ScoreLookUp_channel_penalty_msat(this_arg, candidate, usage, score_params);
9913 return nativeResponseValue;
9916 export interface LDKScoreUpdate {
9917 payment_path_failed (path: bigint, short_channel_id: bigint, duration_since_epoch: bigint): void;
9918 payment_path_successful (path: bigint, duration_since_epoch: bigint): void;
9919 probe_failed (path: bigint, short_channel_id: bigint, duration_since_epoch: bigint): void;
9920 probe_successful (path: bigint, duration_since_epoch: bigint): void;
9921 time_passed (duration_since_epoch: bigint): void;
9925 export function LDKScoreUpdate_new(impl: LDKScoreUpdate): [bigint, number] {
9926 if(!isWasmInitialized) {
9927 throw new Error("initializeWasm() must be awaited first!");
9929 var new_obj_idx = js_objs.length;
9930 for (var i = 0; i < js_objs.length; i++) {
9931 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9933 js_objs[i] = new WeakRef(impl);
9934 return [wasm.TS_LDKScoreUpdate_new(i), i];
9936 // void ScoreUpdate_payment_path_failed LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch
9938 export function ScoreUpdate_payment_path_failed(this_arg: bigint, path: bigint, short_channel_id: bigint, duration_since_epoch: bigint): void {
9939 if(!isWasmInitialized) {
9940 throw new Error("initializeWasm() must be awaited first!");
9942 const nativeResponseValue = wasm.TS_ScoreUpdate_payment_path_failed(this_arg, path, short_channel_id, duration_since_epoch);
9943 // debug statements here
9945 // void ScoreUpdate_payment_path_successful LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch
9947 export function ScoreUpdate_payment_path_successful(this_arg: bigint, path: bigint, duration_since_epoch: bigint): void {
9948 if(!isWasmInitialized) {
9949 throw new Error("initializeWasm() must be awaited first!");
9951 const nativeResponseValue = wasm.TS_ScoreUpdate_payment_path_successful(this_arg, path, duration_since_epoch);
9952 // debug statements here
9954 // void ScoreUpdate_probe_failed LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch
9956 export function ScoreUpdate_probe_failed(this_arg: bigint, path: bigint, short_channel_id: bigint, duration_since_epoch: bigint): void {
9957 if(!isWasmInitialized) {
9958 throw new Error("initializeWasm() must be awaited first!");
9960 const nativeResponseValue = wasm.TS_ScoreUpdate_probe_failed(this_arg, path, short_channel_id, duration_since_epoch);
9961 // debug statements here
9963 // void ScoreUpdate_probe_successful LDKScoreUpdate *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch
9965 export function ScoreUpdate_probe_successful(this_arg: bigint, path: bigint, duration_since_epoch: bigint): void {
9966 if(!isWasmInitialized) {
9967 throw new Error("initializeWasm() must be awaited first!");
9969 const nativeResponseValue = wasm.TS_ScoreUpdate_probe_successful(this_arg, path, duration_since_epoch);
9970 // debug statements here
9972 // void ScoreUpdate_time_passed LDKScoreUpdate *NONNULL_PTR this_arg, uint64_t duration_since_epoch
9974 export function ScoreUpdate_time_passed(this_arg: bigint, duration_since_epoch: bigint): void {
9975 if(!isWasmInitialized) {
9976 throw new Error("initializeWasm() must be awaited first!");
9978 const nativeResponseValue = wasm.TS_ScoreUpdate_time_passed(this_arg, duration_since_epoch);
9979 // debug statements here
9982 export interface LDKLockableScore {
9983 read_lock (): bigint;
9984 write_lock (): bigint;
9988 export function LDKLockableScore_new(impl: LDKLockableScore): [bigint, number] {
9989 if(!isWasmInitialized) {
9990 throw new Error("initializeWasm() must be awaited first!");
9992 var new_obj_idx = js_objs.length;
9993 for (var i = 0; i < js_objs.length; i++) {
9994 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
9996 js_objs[i] = new WeakRef(impl);
9997 return [wasm.TS_LDKLockableScore_new(i), i];
9999 // LDKScoreLookUp LockableScore_read_lock LDKLockableScore *NONNULL_PTR this_arg
10001 export function LockableScore_read_lock(this_arg: bigint): bigint {
10002 if(!isWasmInitialized) {
10003 throw new Error("initializeWasm() must be awaited first!");
10005 const nativeResponseValue = wasm.TS_LockableScore_read_lock(this_arg);
10006 return nativeResponseValue;
10008 // LDKScoreUpdate LockableScore_write_lock LDKLockableScore *NONNULL_PTR this_arg
10010 export function LockableScore_write_lock(this_arg: bigint): bigint {
10011 if(!isWasmInitialized) {
10012 throw new Error("initializeWasm() must be awaited first!");
10014 const nativeResponseValue = wasm.TS_LockableScore_write_lock(this_arg);
10015 return nativeResponseValue;
10018 export interface LDKWriteableScore {
10023 export function LDKWriteableScore_new(impl: LDKWriteableScore, LockableScore: number): [bigint, number] {
10024 if(!isWasmInitialized) {
10025 throw new Error("initializeWasm() must be awaited first!");
10027 var new_obj_idx = js_objs.length;
10028 for (var i = 0; i < js_objs.length; i++) {
10029 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10031 js_objs[i] = new WeakRef(impl);
10032 return [wasm.TS_LDKWriteableScore_new(i, LockableScore), i];
10034 // LDKCVec_u8Z WriteableScore_write LDKWriteableScore *NONNULL_PTR this_arg
10036 export function WriteableScore_write(this_arg: bigint): number {
10037 if(!isWasmInitialized) {
10038 throw new Error("initializeWasm() must be awaited first!");
10040 const nativeResponseValue = wasm.TS_WriteableScore_write(this_arg);
10041 return nativeResponseValue;
10044 export interface LDKPersister {
10045 persist_manager (channel_manager: bigint): bigint;
10046 persist_graph (network_graph: bigint): bigint;
10047 persist_scorer (scorer: bigint): bigint;
10051 export function LDKPersister_new(impl: LDKPersister): [bigint, number] {
10052 if(!isWasmInitialized) {
10053 throw new Error("initializeWasm() must be awaited first!");
10055 var new_obj_idx = js_objs.length;
10056 for (var i = 0; i < js_objs.length; i++) {
10057 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10059 js_objs[i] = new WeakRef(impl);
10060 return [wasm.TS_LDKPersister_new(i), i];
10062 // LDKCResult_NoneIOErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
10064 export function Persister_persist_manager(this_arg: bigint, channel_manager: bigint): bigint {
10065 if(!isWasmInitialized) {
10066 throw new Error("initializeWasm() must be awaited first!");
10068 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
10069 return nativeResponseValue;
10071 // LDKCResult_NoneIOErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
10073 export function Persister_persist_graph(this_arg: bigint, network_graph: bigint): bigint {
10074 if(!isWasmInitialized) {
10075 throw new Error("initializeWasm() must be awaited first!");
10077 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
10078 return nativeResponseValue;
10080 // LDKCResult_NoneIOErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKWriteableScore *NONNULL_PTR scorer
10082 export function Persister_persist_scorer(this_arg: bigint, scorer: bigint): bigint {
10083 if(!isWasmInitialized) {
10084 throw new Error("initializeWasm() must be awaited first!");
10086 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
10087 return nativeResponseValue;
10090 export interface LDKPersist {
10091 persist_new_channel (channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
10092 update_persisted_channel (channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus;
10096 export function LDKPersist_new(impl: LDKPersist): [bigint, number] {
10097 if(!isWasmInitialized) {
10098 throw new Error("initializeWasm() must be awaited first!");
10100 var new_obj_idx = js_objs.length;
10101 for (var i = 0; i < js_objs.length; i++) {
10102 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10104 js_objs[i] = new WeakRef(impl);
10105 return [wasm.TS_LDKPersist_new(i), i];
10107 // LDKChannelMonitorUpdateStatus Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
10109 export function Persist_persist_new_channel(this_arg: bigint, channel_id: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
10110 if(!isWasmInitialized) {
10111 throw new Error("initializeWasm() must be awaited first!");
10113 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
10114 return nativeResponseValue;
10116 // 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
10118 export function Persist_update_persisted_channel(this_arg: bigint, channel_id: bigint, update: bigint, data: bigint, update_id: bigint): ChannelMonitorUpdateStatus {
10119 if(!isWasmInitialized) {
10120 throw new Error("initializeWasm() must be awaited first!");
10122 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
10123 return nativeResponseValue;
10126 export interface LDKFutureCallback {
10131 export function LDKFutureCallback_new(impl: LDKFutureCallback): [bigint, number] {
10132 if(!isWasmInitialized) {
10133 throw new Error("initializeWasm() must be awaited first!");
10135 var new_obj_idx = js_objs.length;
10136 for (var i = 0; i < js_objs.length; i++) {
10137 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10139 js_objs[i] = new WeakRef(impl);
10140 return [wasm.TS_LDKFutureCallback_new(i), i];
10142 // void FutureCallback_call LDKFutureCallback *NONNULL_PTR this_arg
10144 export function FutureCallback_call(this_arg: bigint): void {
10145 if(!isWasmInitialized) {
10146 throw new Error("initializeWasm() must be awaited first!");
10148 const nativeResponseValue = wasm.TS_FutureCallback_call(this_arg);
10149 // debug statements here
10152 export interface LDKListen {
10153 filtered_block_connected (header: number, txdata: number, height: number): void;
10154 block_connected (block: number, height: number): void;
10155 block_disconnected (header: number, height: number): void;
10159 export function LDKListen_new(impl: LDKListen): [bigint, number] {
10160 if(!isWasmInitialized) {
10161 throw new Error("initializeWasm() must be awaited first!");
10163 var new_obj_idx = js_objs.length;
10164 for (var i = 0; i < js_objs.length; i++) {
10165 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10167 js_objs[i] = new WeakRef(impl);
10168 return [wasm.TS_LDKListen_new(i), i];
10170 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
10172 export function Listen_filtered_block_connected(this_arg: bigint, header: number, txdata: number, height: number): void {
10173 if(!isWasmInitialized) {
10174 throw new Error("initializeWasm() must be awaited first!");
10176 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
10177 // debug statements here
10179 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
10181 export function Listen_block_connected(this_arg: bigint, block: number, height: number): void {
10182 if(!isWasmInitialized) {
10183 throw new Error("initializeWasm() must be awaited first!");
10185 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
10186 // debug statements here
10188 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
10190 export function Listen_block_disconnected(this_arg: bigint, header: number, height: number): void {
10191 if(!isWasmInitialized) {
10192 throw new Error("initializeWasm() must be awaited first!");
10194 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
10195 // debug statements here
10198 export interface LDKConfirm {
10199 transactions_confirmed (header: number, txdata: number, height: number): void;
10200 transaction_unconfirmed (txid: number): void;
10201 best_block_updated (header: number, height: number): void;
10202 get_relevant_txids (): number;
10206 export function LDKConfirm_new(impl: LDKConfirm): [bigint, number] {
10207 if(!isWasmInitialized) {
10208 throw new Error("initializeWasm() must be awaited first!");
10210 var new_obj_idx = js_objs.length;
10211 for (var i = 0; i < js_objs.length; i++) {
10212 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10214 js_objs[i] = new WeakRef(impl);
10215 return [wasm.TS_LDKConfirm_new(i), i];
10217 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
10219 export function Confirm_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number): void {
10220 if(!isWasmInitialized) {
10221 throw new Error("initializeWasm() must be awaited first!");
10223 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
10224 // debug statements here
10226 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
10228 export function Confirm_transaction_unconfirmed(this_arg: bigint, txid: number): void {
10229 if(!isWasmInitialized) {
10230 throw new Error("initializeWasm() must be awaited first!");
10232 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
10233 // debug statements here
10235 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
10237 export function Confirm_best_block_updated(this_arg: bigint, header: number, height: number): void {
10238 if(!isWasmInitialized) {
10239 throw new Error("initializeWasm() must be awaited first!");
10241 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
10242 // debug statements here
10244 // LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
10246 export function Confirm_get_relevant_txids(this_arg: bigint): number {
10247 if(!isWasmInitialized) {
10248 throw new Error("initializeWasm() must be awaited first!");
10250 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
10251 return nativeResponseValue;
10254 export interface LDKEventHandler {
10255 handle_event (event: bigint): void;
10259 export function LDKEventHandler_new(impl: LDKEventHandler): [bigint, number] {
10260 if(!isWasmInitialized) {
10261 throw new Error("initializeWasm() must be awaited first!");
10263 var new_obj_idx = js_objs.length;
10264 for (var i = 0; i < js_objs.length; i++) {
10265 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10267 js_objs[i] = new WeakRef(impl);
10268 return [wasm.TS_LDKEventHandler_new(i), i];
10270 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, struct LDKEvent event
10272 export function EventHandler_handle_event(this_arg: bigint, event: bigint): void {
10273 if(!isWasmInitialized) {
10274 throw new Error("initializeWasm() must be awaited first!");
10276 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
10277 // debug statements here
10280 export interface LDKEventsProvider {
10281 process_pending_events (handler: bigint): void;
10285 export function LDKEventsProvider_new(impl: LDKEventsProvider): [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_LDKEventsProvider_new(i), i];
10296 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
10298 export function EventsProvider_process_pending_events(this_arg: bigint, handler: bigint): void {
10299 if(!isWasmInitialized) {
10300 throw new Error("initializeWasm() must be awaited first!");
10302 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
10303 // debug statements here
10306 export class LDKFailureCode {
10307 protected constructor() {}
10310 export function LDKFailureCode_ty_from_ptr(ptr: bigint): number {
10311 if(!isWasmInitialized) {
10312 throw new Error("initializeWasm() must be awaited first!");
10314 const nativeResponseValue = wasm.TS_LDKFailureCode_ty_from_ptr(ptr);
10315 return nativeResponseValue;
10318 export function LDKFailureCode_InvalidOnionPayload_get_invalid_onion_payload(ptr: bigint): bigint {
10319 if(!isWasmInitialized) {
10320 throw new Error("initializeWasm() must be awaited first!");
10322 const nativeResponseValue = wasm.TS_LDKFailureCode_InvalidOnionPayload_get_invalid_onion_payload(ptr);
10323 return nativeResponseValue;
10326 export interface LDKMessageSendEventsProvider {
10327 get_and_clear_pending_msg_events (): number;
10331 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): [bigint, number] {
10332 if(!isWasmInitialized) {
10333 throw new Error("initializeWasm() must be awaited first!");
10335 var new_obj_idx = js_objs.length;
10336 for (var i = 0; i < js_objs.length; i++) {
10337 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10339 js_objs[i] = new WeakRef(impl);
10340 return [wasm.TS_LDKMessageSendEventsProvider_new(i), i];
10342 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
10344 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: bigint): number {
10345 if(!isWasmInitialized) {
10346 throw new Error("initializeWasm() must be awaited first!");
10348 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
10349 return nativeResponseValue;
10352 export interface LDKChannelMessageHandler {
10353 handle_open_channel (their_node_id: number, msg: bigint): void;
10354 handle_open_channel_v2 (their_node_id: number, msg: bigint): void;
10355 handle_accept_channel (their_node_id: number, msg: bigint): void;
10356 handle_accept_channel_v2 (their_node_id: number, msg: bigint): void;
10357 handle_funding_created (their_node_id: number, msg: bigint): void;
10358 handle_funding_signed (their_node_id: number, msg: bigint): void;
10359 handle_channel_ready (their_node_id: number, msg: bigint): void;
10360 handle_shutdown (their_node_id: number, msg: bigint): void;
10361 handle_closing_signed (their_node_id: number, msg: bigint): void;
10362 handle_stfu (their_node_id: number, msg: bigint): void;
10363 handle_splice (their_node_id: number, msg: bigint): void;
10364 handle_splice_ack (their_node_id: number, msg: bigint): void;
10365 handle_splice_locked (their_node_id: number, msg: bigint): void;
10366 handle_tx_add_input (their_node_id: number, msg: bigint): void;
10367 handle_tx_add_output (their_node_id: number, msg: bigint): void;
10368 handle_tx_remove_input (their_node_id: number, msg: bigint): void;
10369 handle_tx_remove_output (their_node_id: number, msg: bigint): void;
10370 handle_tx_complete (their_node_id: number, msg: bigint): void;
10371 handle_tx_signatures (their_node_id: number, msg: bigint): void;
10372 handle_tx_init_rbf (their_node_id: number, msg: bigint): void;
10373 handle_tx_ack_rbf (their_node_id: number, msg: bigint): void;
10374 handle_tx_abort (their_node_id: number, msg: bigint): void;
10375 handle_update_add_htlc (their_node_id: number, msg: bigint): void;
10376 handle_update_fulfill_htlc (their_node_id: number, msg: bigint): void;
10377 handle_update_fail_htlc (their_node_id: number, msg: bigint): void;
10378 handle_update_fail_malformed_htlc (their_node_id: number, msg: bigint): void;
10379 handle_commitment_signed (their_node_id: number, msg: bigint): void;
10380 handle_revoke_and_ack (their_node_id: number, msg: bigint): void;
10381 handle_update_fee (their_node_id: number, msg: bigint): void;
10382 handle_announcement_signatures (their_node_id: number, msg: bigint): void;
10383 peer_disconnected (their_node_id: number): void;
10384 peer_connected (their_node_id: number, msg: bigint, inbound: boolean): bigint;
10385 handle_channel_reestablish (their_node_id: number, msg: bigint): void;
10386 handle_channel_update (their_node_id: number, msg: bigint): void;
10387 handle_error (their_node_id: number, msg: bigint): void;
10388 provided_node_features (): bigint;
10389 provided_init_features (their_node_id: number): bigint;
10390 get_chain_hashes (): bigint;
10394 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
10395 if(!isWasmInitialized) {
10396 throw new Error("initializeWasm() must be awaited first!");
10398 var new_obj_idx = js_objs.length;
10399 for (var i = 0; i < js_objs.length; i++) {
10400 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10402 js_objs[i] = new WeakRef(impl);
10403 return [wasm.TS_LDKChannelMessageHandler_new(i, MessageSendEventsProvider), i];
10405 // void ChannelMessageHandler_handle_open_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg
10407 export function ChannelMessageHandler_handle_open_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
10408 if(!isWasmInitialized) {
10409 throw new Error("initializeWasm() must be awaited first!");
10411 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, msg);
10412 // debug statements here
10414 // void ChannelMessageHandler_handle_open_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg
10416 export function ChannelMessageHandler_handle_open_channel_v2(this_arg: bigint, their_node_id: number, msg: bigint): void {
10417 if(!isWasmInitialized) {
10418 throw new Error("initializeWasm() must be awaited first!");
10420 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel_v2(this_arg, their_node_id, msg);
10421 // debug statements here
10423 // void ChannelMessageHandler_handle_accept_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg
10425 export function ChannelMessageHandler_handle_accept_channel(this_arg: bigint, their_node_id: number, msg: bigint): void {
10426 if(!isWasmInitialized) {
10427 throw new Error("initializeWasm() must be awaited first!");
10429 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, msg);
10430 // debug statements here
10432 // void ChannelMessageHandler_handle_accept_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg
10434 export function ChannelMessageHandler_handle_accept_channel_v2(this_arg: bigint, their_node_id: number, msg: bigint): void {
10435 if(!isWasmInitialized) {
10436 throw new Error("initializeWasm() must be awaited first!");
10438 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel_v2(this_arg, their_node_id, msg);
10439 // debug statements here
10441 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
10443 export function ChannelMessageHandler_handle_funding_created(this_arg: bigint, their_node_id: number, msg: bigint): void {
10444 if(!isWasmInitialized) {
10445 throw new Error("initializeWasm() must be awaited first!");
10447 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
10448 // debug statements here
10450 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
10452 export function ChannelMessageHandler_handle_funding_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
10453 if(!isWasmInitialized) {
10454 throw new Error("initializeWasm() must be awaited first!");
10456 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
10457 // debug statements here
10459 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
10461 export function ChannelMessageHandler_handle_channel_ready(this_arg: bigint, their_node_id: number, msg: bigint): void {
10462 if(!isWasmInitialized) {
10463 throw new Error("initializeWasm() must be awaited first!");
10465 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
10466 // debug statements here
10468 // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg
10470 export function ChannelMessageHandler_handle_shutdown(this_arg: bigint, their_node_id: number, msg: bigint): void {
10471 if(!isWasmInitialized) {
10472 throw new Error("initializeWasm() must be awaited first!");
10474 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, msg);
10475 // debug statements here
10477 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
10479 export function ChannelMessageHandler_handle_closing_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
10480 if(!isWasmInitialized) {
10481 throw new Error("initializeWasm() must be awaited first!");
10483 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
10484 // debug statements here
10486 // void ChannelMessageHandler_handle_stfu LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg
10488 export function ChannelMessageHandler_handle_stfu(this_arg: bigint, their_node_id: number, msg: bigint): void {
10489 if(!isWasmInitialized) {
10490 throw new Error("initializeWasm() must be awaited first!");
10492 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_stfu(this_arg, their_node_id, msg);
10493 // debug statements here
10495 // void ChannelMessageHandler_handle_splice LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKSplice *NONNULL_PTR msg
10497 export function ChannelMessageHandler_handle_splice(this_arg: bigint, their_node_id: number, msg: bigint): void {
10498 if(!isWasmInitialized) {
10499 throw new Error("initializeWasm() must be awaited first!");
10501 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_splice(this_arg, their_node_id, msg);
10502 // debug statements here
10504 // void ChannelMessageHandler_handle_splice_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKSpliceAck *NONNULL_PTR msg
10506 export function ChannelMessageHandler_handle_splice_ack(this_arg: bigint, their_node_id: number, msg: bigint): void {
10507 if(!isWasmInitialized) {
10508 throw new Error("initializeWasm() must be awaited first!");
10510 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_splice_ack(this_arg, their_node_id, msg);
10511 // debug statements here
10513 // void ChannelMessageHandler_handle_splice_locked LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKSpliceLocked *NONNULL_PTR msg
10515 export function ChannelMessageHandler_handle_splice_locked(this_arg: bigint, their_node_id: number, msg: bigint): void {
10516 if(!isWasmInitialized) {
10517 throw new Error("initializeWasm() must be awaited first!");
10519 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_splice_locked(this_arg, their_node_id, msg);
10520 // debug statements here
10522 // void ChannelMessageHandler_handle_tx_add_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg
10524 export function ChannelMessageHandler_handle_tx_add_input(this_arg: bigint, their_node_id: number, msg: bigint): void {
10525 if(!isWasmInitialized) {
10526 throw new Error("initializeWasm() must be awaited first!");
10528 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_add_input(this_arg, their_node_id, msg);
10529 // debug statements here
10531 // void ChannelMessageHandler_handle_tx_add_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg
10533 export function ChannelMessageHandler_handle_tx_add_output(this_arg: bigint, their_node_id: number, msg: bigint): void {
10534 if(!isWasmInitialized) {
10535 throw new Error("initializeWasm() must be awaited first!");
10537 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_add_output(this_arg, their_node_id, msg);
10538 // debug statements here
10540 // void ChannelMessageHandler_handle_tx_remove_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg
10542 export function ChannelMessageHandler_handle_tx_remove_input(this_arg: bigint, their_node_id: number, msg: bigint): void {
10543 if(!isWasmInitialized) {
10544 throw new Error("initializeWasm() must be awaited first!");
10546 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_remove_input(this_arg, their_node_id, msg);
10547 // debug statements here
10549 // void ChannelMessageHandler_handle_tx_remove_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg
10551 export function ChannelMessageHandler_handle_tx_remove_output(this_arg: bigint, their_node_id: number, msg: bigint): void {
10552 if(!isWasmInitialized) {
10553 throw new Error("initializeWasm() must be awaited first!");
10555 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_remove_output(this_arg, their_node_id, msg);
10556 // debug statements here
10558 // void ChannelMessageHandler_handle_tx_complete LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg
10560 export function ChannelMessageHandler_handle_tx_complete(this_arg: bigint, their_node_id: number, msg: bigint): void {
10561 if(!isWasmInitialized) {
10562 throw new Error("initializeWasm() must be awaited first!");
10564 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_complete(this_arg, their_node_id, msg);
10565 // debug statements here
10567 // void ChannelMessageHandler_handle_tx_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg
10569 export function ChannelMessageHandler_handle_tx_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
10570 if(!isWasmInitialized) {
10571 throw new Error("initializeWasm() must be awaited first!");
10573 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_signatures(this_arg, their_node_id, msg);
10574 // debug statements here
10576 // void ChannelMessageHandler_handle_tx_init_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg
10578 export function ChannelMessageHandler_handle_tx_init_rbf(this_arg: bigint, their_node_id: number, msg: bigint): void {
10579 if(!isWasmInitialized) {
10580 throw new Error("initializeWasm() must be awaited first!");
10582 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_init_rbf(this_arg, their_node_id, msg);
10583 // debug statements here
10585 // void ChannelMessageHandler_handle_tx_ack_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg
10587 export function ChannelMessageHandler_handle_tx_ack_rbf(this_arg: bigint, their_node_id: number, msg: bigint): void {
10588 if(!isWasmInitialized) {
10589 throw new Error("initializeWasm() must be awaited first!");
10591 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_ack_rbf(this_arg, their_node_id, msg);
10592 // debug statements here
10594 // void ChannelMessageHandler_handle_tx_abort LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg
10596 export function ChannelMessageHandler_handle_tx_abort(this_arg: bigint, their_node_id: number, msg: bigint): void {
10597 if(!isWasmInitialized) {
10598 throw new Error("initializeWasm() must be awaited first!");
10600 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_tx_abort(this_arg, their_node_id, msg);
10601 // debug statements here
10603 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
10605 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
10606 if(!isWasmInitialized) {
10607 throw new Error("initializeWasm() must be awaited first!");
10609 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
10610 // debug statements here
10612 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
10614 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
10615 if(!isWasmInitialized) {
10616 throw new Error("initializeWasm() must be awaited first!");
10618 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
10619 // debug statements here
10621 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
10623 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
10624 if(!isWasmInitialized) {
10625 throw new Error("initializeWasm() must be awaited first!");
10627 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
10628 // debug statements here
10630 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
10632 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: bigint, their_node_id: number, msg: bigint): void {
10633 if(!isWasmInitialized) {
10634 throw new Error("initializeWasm() must be awaited first!");
10636 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
10637 // debug statements here
10639 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
10641 export function ChannelMessageHandler_handle_commitment_signed(this_arg: bigint, their_node_id: number, msg: bigint): void {
10642 if(!isWasmInitialized) {
10643 throw new Error("initializeWasm() must be awaited first!");
10645 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
10646 // debug statements here
10648 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
10650 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: bigint, their_node_id: number, msg: bigint): void {
10651 if(!isWasmInitialized) {
10652 throw new Error("initializeWasm() must be awaited first!");
10654 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
10655 // debug statements here
10657 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
10659 export function ChannelMessageHandler_handle_update_fee(this_arg: bigint, their_node_id: number, msg: bigint): void {
10660 if(!isWasmInitialized) {
10661 throw new Error("initializeWasm() must be awaited first!");
10663 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
10664 // debug statements here
10666 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
10668 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: bigint, their_node_id: number, msg: bigint): void {
10669 if(!isWasmInitialized) {
10670 throw new Error("initializeWasm() must be awaited first!");
10672 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
10673 // debug statements here
10675 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10677 export function ChannelMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
10678 if(!isWasmInitialized) {
10679 throw new Error("initializeWasm() must be awaited first!");
10681 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id);
10682 // debug statements here
10684 // LDKCResult_NoneNoneZ ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound
10686 export function ChannelMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, msg: bigint, inbound: boolean): bigint {
10687 if(!isWasmInitialized) {
10688 throw new Error("initializeWasm() must be awaited first!");
10690 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg, inbound);
10691 return nativeResponseValue;
10693 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
10695 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: bigint, their_node_id: number, msg: bigint): void {
10696 if(!isWasmInitialized) {
10697 throw new Error("initializeWasm() must be awaited first!");
10699 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
10700 // debug statements here
10702 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
10704 export function ChannelMessageHandler_handle_channel_update(this_arg: bigint, their_node_id: number, msg: bigint): void {
10705 if(!isWasmInitialized) {
10706 throw new Error("initializeWasm() must be awaited first!");
10708 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
10709 // debug statements here
10711 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
10713 export function ChannelMessageHandler_handle_error(this_arg: bigint, their_node_id: number, msg: bigint): void {
10714 if(!isWasmInitialized) {
10715 throw new Error("initializeWasm() must be awaited first!");
10717 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
10718 // debug statements here
10720 // LDKNodeFeatures ChannelMessageHandler_provided_node_features LDKChannelMessageHandler *NONNULL_PTR this_arg
10722 export function ChannelMessageHandler_provided_node_features(this_arg: bigint): bigint {
10723 if(!isWasmInitialized) {
10724 throw new Error("initializeWasm() must be awaited first!");
10726 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_node_features(this_arg);
10727 return nativeResponseValue;
10729 // LDKInitFeatures ChannelMessageHandler_provided_init_features LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10731 export function ChannelMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
10732 if(!isWasmInitialized) {
10733 throw new Error("initializeWasm() must be awaited first!");
10735 const nativeResponseValue = wasm.TS_ChannelMessageHandler_provided_init_features(this_arg, their_node_id);
10736 return nativeResponseValue;
10738 // LDKCOption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler_get_chain_hashes LDKChannelMessageHandler *NONNULL_PTR this_arg
10740 export function ChannelMessageHandler_get_chain_hashes(this_arg: bigint): bigint {
10741 if(!isWasmInitialized) {
10742 throw new Error("initializeWasm() must be awaited first!");
10744 const nativeResponseValue = wasm.TS_ChannelMessageHandler_get_chain_hashes(this_arg);
10745 return nativeResponseValue;
10748 export interface LDKOffersMessageHandler {
10749 handle_message (message: bigint): bigint;
10750 release_pending_messages (): number;
10754 export function LDKOffersMessageHandler_new(impl: LDKOffersMessageHandler): [bigint, number] {
10755 if(!isWasmInitialized) {
10756 throw new Error("initializeWasm() must be awaited first!");
10758 var new_obj_idx = js_objs.length;
10759 for (var i = 0; i < js_objs.length; i++) {
10760 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10762 js_objs[i] = new WeakRef(impl);
10763 return [wasm.TS_LDKOffersMessageHandler_new(i), i];
10765 // LDKCOption_OffersMessageZ OffersMessageHandler_handle_message LDKOffersMessageHandler *NONNULL_PTR this_arg, struct LDKOffersMessage message
10767 export function OffersMessageHandler_handle_message(this_arg: bigint, message: bigint): bigint {
10768 if(!isWasmInitialized) {
10769 throw new Error("initializeWasm() must be awaited first!");
10771 const nativeResponseValue = wasm.TS_OffersMessageHandler_handle_message(this_arg, message);
10772 return nativeResponseValue;
10774 // LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ OffersMessageHandler_release_pending_messages LDKOffersMessageHandler *NONNULL_PTR this_arg
10776 export function OffersMessageHandler_release_pending_messages(this_arg: bigint): number {
10777 if(!isWasmInitialized) {
10778 throw new Error("initializeWasm() must be awaited first!");
10780 const nativeResponseValue = wasm.TS_OffersMessageHandler_release_pending_messages(this_arg);
10781 return nativeResponseValue;
10784 export interface LDKRoutingMessageHandler {
10785 handle_node_announcement (msg: bigint): bigint;
10786 handle_channel_announcement (msg: bigint): bigint;
10787 handle_channel_update (msg: bigint): bigint;
10788 get_next_channel_announcement (starting_point: bigint): bigint;
10789 get_next_node_announcement (starting_point: bigint): bigint;
10790 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
10791 handle_reply_channel_range (their_node_id: number, msg: bigint): bigint;
10792 handle_reply_short_channel_ids_end (their_node_id: number, msg: bigint): bigint;
10793 handle_query_channel_range (their_node_id: number, msg: bigint): bigint;
10794 handle_query_short_channel_ids (their_node_id: number, msg: bigint): bigint;
10795 processing_queue_high (): boolean;
10796 provided_node_features (): bigint;
10797 provided_init_features (their_node_id: number): bigint;
10801 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: number): [bigint, number] {
10802 if(!isWasmInitialized) {
10803 throw new Error("initializeWasm() must be awaited first!");
10805 var new_obj_idx = js_objs.length;
10806 for (var i = 0; i < js_objs.length; i++) {
10807 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10809 js_objs[i] = new WeakRef(impl);
10810 return [wasm.TS_LDKRoutingMessageHandler_new(i, MessageSendEventsProvider), i];
10812 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
10814 export function RoutingMessageHandler_handle_node_announcement(this_arg: bigint, msg: bigint): bigint {
10815 if(!isWasmInitialized) {
10816 throw new Error("initializeWasm() must be awaited first!");
10818 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
10819 return nativeResponseValue;
10821 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
10823 export function RoutingMessageHandler_handle_channel_announcement(this_arg: bigint, msg: bigint): bigint {
10824 if(!isWasmInitialized) {
10825 throw new Error("initializeWasm() must be awaited first!");
10827 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
10828 return nativeResponseValue;
10830 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
10832 export function RoutingMessageHandler_handle_channel_update(this_arg: bigint, msg: bigint): bigint {
10833 if(!isWasmInitialized) {
10834 throw new Error("initializeWasm() must be awaited first!");
10836 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
10837 return nativeResponseValue;
10839 // LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point
10841 export function RoutingMessageHandler_get_next_channel_announcement(this_arg: bigint, starting_point: bigint): bigint {
10842 if(!isWasmInitialized) {
10843 throw new Error("initializeWasm() must be awaited first!");
10845 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcement(this_arg, starting_point);
10846 return nativeResponseValue;
10848 // LDKNodeAnnouncement RoutingMessageHandler_get_next_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKNodeId starting_point
10850 export function RoutingMessageHandler_get_next_node_announcement(this_arg: bigint, starting_point: bigint): bigint {
10851 if(!isWasmInitialized) {
10852 throw new Error("initializeWasm() must be awaited first!");
10854 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcement(this_arg, starting_point);
10855 return nativeResponseValue;
10857 // LDKCResult_NoneNoneZ RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
10859 export function RoutingMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
10860 if(!isWasmInitialized) {
10861 throw new Error("initializeWasm() must be awaited first!");
10863 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
10864 return nativeResponseValue;
10866 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
10868 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
10869 if(!isWasmInitialized) {
10870 throw new Error("initializeWasm() must be awaited first!");
10872 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
10873 return nativeResponseValue;
10875 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
10877 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
10878 if(!isWasmInitialized) {
10879 throw new Error("initializeWasm() must be awaited first!");
10881 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
10882 return nativeResponseValue;
10884 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
10886 export function RoutingMessageHandler_handle_query_channel_range(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
10887 if(!isWasmInitialized) {
10888 throw new Error("initializeWasm() must be awaited first!");
10890 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
10891 return nativeResponseValue;
10893 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
10895 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: bigint, their_node_id: number, msg: bigint): bigint {
10896 if(!isWasmInitialized) {
10897 throw new Error("initializeWasm() must be awaited first!");
10899 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
10900 return nativeResponseValue;
10902 // bool RoutingMessageHandler_processing_queue_high LDKRoutingMessageHandler *NONNULL_PTR this_arg
10904 export function RoutingMessageHandler_processing_queue_high(this_arg: bigint): boolean {
10905 if(!isWasmInitialized) {
10906 throw new Error("initializeWasm() must be awaited first!");
10908 const nativeResponseValue = wasm.TS_RoutingMessageHandler_processing_queue_high(this_arg);
10909 return nativeResponseValue;
10911 // LDKNodeFeatures RoutingMessageHandler_provided_node_features LDKRoutingMessageHandler *NONNULL_PTR this_arg
10913 export function RoutingMessageHandler_provided_node_features(this_arg: bigint): bigint {
10914 if(!isWasmInitialized) {
10915 throw new Error("initializeWasm() must be awaited first!");
10917 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_node_features(this_arg);
10918 return nativeResponseValue;
10920 // LDKInitFeatures RoutingMessageHandler_provided_init_features LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10922 export function RoutingMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
10923 if(!isWasmInitialized) {
10924 throw new Error("initializeWasm() must be awaited first!");
10926 const nativeResponseValue = wasm.TS_RoutingMessageHandler_provided_init_features(this_arg, their_node_id);
10927 return nativeResponseValue;
10930 export interface LDKOnionMessageHandler {
10931 get_and_clear_connections_needed (): number;
10932 handle_onion_message (peer_node_id: number, msg: bigint): void;
10933 next_onion_message_for_peer (peer_node_id: number): bigint;
10934 peer_connected (their_node_id: number, init: bigint, inbound: boolean): bigint;
10935 peer_disconnected (their_node_id: number): void;
10936 timer_tick_occurred (): void;
10937 provided_node_features (): bigint;
10938 provided_init_features (their_node_id: number): bigint;
10942 export function LDKOnionMessageHandler_new(impl: LDKOnionMessageHandler): [bigint, number] {
10943 if(!isWasmInitialized) {
10944 throw new Error("initializeWasm() must be awaited first!");
10946 var new_obj_idx = js_objs.length;
10947 for (var i = 0; i < js_objs.length; i++) {
10948 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
10950 js_objs[i] = new WeakRef(impl);
10951 return [wasm.TS_LDKOnionMessageHandler_new(i), i];
10953 // LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ OnionMessageHandler_get_and_clear_connections_needed LDKOnionMessageHandler *NONNULL_PTR this_arg
10955 export function OnionMessageHandler_get_and_clear_connections_needed(this_arg: bigint): number {
10956 if(!isWasmInitialized) {
10957 throw new Error("initializeWasm() must be awaited first!");
10959 const nativeResponseValue = wasm.TS_OnionMessageHandler_get_and_clear_connections_needed(this_arg);
10960 return nativeResponseValue;
10962 // void OnionMessageHandler_handle_onion_message LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg
10964 export function OnionMessageHandler_handle_onion_message(this_arg: bigint, peer_node_id: number, msg: bigint): void {
10965 if(!isWasmInitialized) {
10966 throw new Error("initializeWasm() must be awaited first!");
10968 const nativeResponseValue = wasm.TS_OnionMessageHandler_handle_onion_message(this_arg, peer_node_id, msg);
10969 // debug statements here
10971 // LDKOnionMessage OnionMessageHandler_next_onion_message_for_peer LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
10973 export function OnionMessageHandler_next_onion_message_for_peer(this_arg: bigint, peer_node_id: number): bigint {
10974 if(!isWasmInitialized) {
10975 throw new Error("initializeWasm() must be awaited first!");
10977 const nativeResponseValue = wasm.TS_OnionMessageHandler_next_onion_message_for_peer(this_arg, peer_node_id);
10978 return nativeResponseValue;
10980 // LDKCResult_NoneNoneZ OnionMessageHandler_peer_connected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
10982 export function OnionMessageHandler_peer_connected(this_arg: bigint, their_node_id: number, init: bigint, inbound: boolean): bigint {
10983 if(!isWasmInitialized) {
10984 throw new Error("initializeWasm() must be awaited first!");
10986 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_connected(this_arg, their_node_id, init, inbound);
10987 return nativeResponseValue;
10989 // void OnionMessageHandler_peer_disconnected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
10991 export function OnionMessageHandler_peer_disconnected(this_arg: bigint, their_node_id: number): void {
10992 if(!isWasmInitialized) {
10993 throw new Error("initializeWasm() must be awaited first!");
10995 const nativeResponseValue = wasm.TS_OnionMessageHandler_peer_disconnected(this_arg, their_node_id);
10996 // debug statements here
10998 // void OnionMessageHandler_timer_tick_occurred LDKOnionMessageHandler *NONNULL_PTR this_arg
11000 export function OnionMessageHandler_timer_tick_occurred(this_arg: bigint): void {
11001 if(!isWasmInitialized) {
11002 throw new Error("initializeWasm() must be awaited first!");
11004 const nativeResponseValue = wasm.TS_OnionMessageHandler_timer_tick_occurred(this_arg);
11005 // debug statements here
11007 // LDKNodeFeatures OnionMessageHandler_provided_node_features LDKOnionMessageHandler *NONNULL_PTR this_arg
11009 export function OnionMessageHandler_provided_node_features(this_arg: bigint): bigint {
11010 if(!isWasmInitialized) {
11011 throw new Error("initializeWasm() must be awaited first!");
11013 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_node_features(this_arg);
11014 return nativeResponseValue;
11016 // LDKInitFeatures OnionMessageHandler_provided_init_features LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
11018 export function OnionMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
11019 if(!isWasmInitialized) {
11020 throw new Error("initializeWasm() must be awaited first!");
11022 const nativeResponseValue = wasm.TS_OnionMessageHandler_provided_init_features(this_arg, their_node_id);
11023 return nativeResponseValue;
11026 export interface LDKCustomMessageReader {
11027 read (message_type: number, buffer: number): bigint;
11031 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): [bigint, number] {
11032 if(!isWasmInitialized) {
11033 throw new Error("initializeWasm() must be awaited first!");
11035 var new_obj_idx = js_objs.length;
11036 for (var i = 0; i < js_objs.length; i++) {
11037 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11039 js_objs[i] = new WeakRef(impl);
11040 return [wasm.TS_LDKCustomMessageReader_new(i), i];
11042 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
11044 export function CustomMessageReader_read(this_arg: bigint, message_type: number, buffer: number): bigint {
11045 if(!isWasmInitialized) {
11046 throw new Error("initializeWasm() must be awaited first!");
11048 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
11049 return nativeResponseValue;
11052 export interface LDKCustomMessageHandler {
11053 handle_custom_message (msg: bigint, sender_node_id: number): bigint;
11054 get_and_clear_pending_msg (): number;
11055 provided_node_features (): bigint;
11056 provided_init_features (their_node_id: number): bigint;
11060 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: number): [bigint, number] {
11061 if(!isWasmInitialized) {
11062 throw new Error("initializeWasm() must be awaited first!");
11064 var new_obj_idx = js_objs.length;
11065 for (var i = 0; i < js_objs.length; i++) {
11066 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11068 js_objs[i] = new WeakRef(impl);
11069 return [wasm.TS_LDKCustomMessageHandler_new(i, CustomMessageReader), i];
11071 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
11073 export function CustomMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint, sender_node_id: number): bigint {
11074 if(!isWasmInitialized) {
11075 throw new Error("initializeWasm() must be awaited first!");
11077 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
11078 return nativeResponseValue;
11080 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
11082 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: bigint): number {
11083 if(!isWasmInitialized) {
11084 throw new Error("initializeWasm() must be awaited first!");
11086 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
11087 return nativeResponseValue;
11089 // LDKNodeFeatures CustomMessageHandler_provided_node_features LDKCustomMessageHandler *NONNULL_PTR this_arg
11091 export function CustomMessageHandler_provided_node_features(this_arg: bigint): bigint {
11092 if(!isWasmInitialized) {
11093 throw new Error("initializeWasm() must be awaited first!");
11095 const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_node_features(this_arg);
11096 return nativeResponseValue;
11098 // LDKInitFeatures CustomMessageHandler_provided_init_features LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
11100 export function CustomMessageHandler_provided_init_features(this_arg: bigint, their_node_id: number): bigint {
11101 if(!isWasmInitialized) {
11102 throw new Error("initializeWasm() must be awaited first!");
11104 const nativeResponseValue = wasm.TS_CustomMessageHandler_provided_init_features(this_arg, their_node_id);
11105 return nativeResponseValue;
11108 export interface LDKCustomOnionMessageHandler {
11109 handle_custom_message (msg: bigint): bigint;
11110 read_custom_message (message_type: bigint, buffer: number): bigint;
11111 release_pending_custom_messages (): number;
11115 export function LDKCustomOnionMessageHandler_new(impl: LDKCustomOnionMessageHandler): [bigint, number] {
11116 if(!isWasmInitialized) {
11117 throw new Error("initializeWasm() must be awaited first!");
11119 var new_obj_idx = js_objs.length;
11120 for (var i = 0; i < js_objs.length; i++) {
11121 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11123 js_objs[i] = new WeakRef(impl);
11124 return [wasm.TS_LDKCustomOnionMessageHandler_new(i), i];
11126 // LDKCOption_OnionMessageContentsZ CustomOnionMessageHandler_handle_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, struct LDKOnionMessageContents msg
11128 export function CustomOnionMessageHandler_handle_custom_message(this_arg: bigint, msg: bigint): bigint {
11129 if(!isWasmInitialized) {
11130 throw new Error("initializeWasm() must be awaited first!");
11132 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_handle_custom_message(this_arg, msg);
11133 return nativeResponseValue;
11135 // LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler_read_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, uint64_t message_type, struct LDKu8slice buffer
11137 export function CustomOnionMessageHandler_read_custom_message(this_arg: bigint, message_type: bigint, buffer: number): bigint {
11138 if(!isWasmInitialized) {
11139 throw new Error("initializeWasm() must be awaited first!");
11141 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_read_custom_message(this_arg, message_type, buffer);
11142 return nativeResponseValue;
11144 // LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ CustomOnionMessageHandler_release_pending_custom_messages LDKCustomOnionMessageHandler *NONNULL_PTR this_arg
11146 export function CustomOnionMessageHandler_release_pending_custom_messages(this_arg: bigint): number {
11147 if(!isWasmInitialized) {
11148 throw new Error("initializeWasm() must be awaited first!");
11150 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_release_pending_custom_messages(this_arg);
11151 return nativeResponseValue;
11154 export interface LDKSocketDescriptor {
11155 send_data (data: number, resume_read: boolean): number;
11156 disconnect_socket (): void;
11157 eq (other_arg: bigint): boolean;
11162 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): [bigint, number] {
11163 if(!isWasmInitialized) {
11164 throw new Error("initializeWasm() must be awaited first!");
11166 var new_obj_idx = js_objs.length;
11167 for (var i = 0; i < js_objs.length; i++) {
11168 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11170 js_objs[i] = new WeakRef(impl);
11171 return [wasm.TS_LDKSocketDescriptor_new(i), i];
11173 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
11175 export function SocketDescriptor_send_data(this_arg: bigint, data: number, resume_read: boolean): number {
11176 if(!isWasmInitialized) {
11177 throw new Error("initializeWasm() must be awaited first!");
11179 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
11180 return nativeResponseValue;
11182 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
11184 export function SocketDescriptor_disconnect_socket(this_arg: bigint): void {
11185 if(!isWasmInitialized) {
11186 throw new Error("initializeWasm() must be awaited first!");
11188 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
11189 // debug statements here
11191 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
11193 export function SocketDescriptor_hash(this_arg: bigint): bigint {
11194 if(!isWasmInitialized) {
11195 throw new Error("initializeWasm() must be awaited first!");
11197 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
11198 return nativeResponseValue;
11201 export class LDKEffectiveCapacity {
11202 protected constructor() {}
11205 export function LDKEffectiveCapacity_ty_from_ptr(ptr: bigint): number {
11206 if(!isWasmInitialized) {
11207 throw new Error("initializeWasm() must be awaited first!");
11209 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
11210 return nativeResponseValue;
11213 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: bigint): bigint {
11214 if(!isWasmInitialized) {
11215 throw new Error("initializeWasm() must be awaited first!");
11217 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
11218 return nativeResponseValue;
11221 export function LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr: bigint): bigint {
11222 if(!isWasmInitialized) {
11223 throw new Error("initializeWasm() must be awaited first!");
11225 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(ptr);
11226 return nativeResponseValue;
11229 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: bigint): bigint {
11230 if(!isWasmInitialized) {
11231 throw new Error("initializeWasm() must be awaited first!");
11233 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
11234 return nativeResponseValue;
11237 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: bigint): bigint {
11238 if(!isWasmInitialized) {
11239 throw new Error("initializeWasm() must be awaited first!");
11241 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
11242 return nativeResponseValue;
11245 export function LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr: bigint): bigint {
11246 if(!isWasmInitialized) {
11247 throw new Error("initializeWasm() must be awaited first!");
11249 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(ptr);
11250 return nativeResponseValue;
11253 export class LDKPayee {
11254 protected constructor() {}
11257 export function LDKPayee_ty_from_ptr(ptr: bigint): number {
11258 if(!isWasmInitialized) {
11259 throw new Error("initializeWasm() must be awaited first!");
11261 const nativeResponseValue = wasm.TS_LDKPayee_ty_from_ptr(ptr);
11262 return nativeResponseValue;
11265 export function LDKPayee_Blinded_get_route_hints(ptr: bigint): number {
11266 if(!isWasmInitialized) {
11267 throw new Error("initializeWasm() must be awaited first!");
11269 const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_route_hints(ptr);
11270 return nativeResponseValue;
11273 export function LDKPayee_Blinded_get_features(ptr: bigint): bigint {
11274 if(!isWasmInitialized) {
11275 throw new Error("initializeWasm() must be awaited first!");
11277 const nativeResponseValue = wasm.TS_LDKPayee_Blinded_get_features(ptr);
11278 return nativeResponseValue;
11281 export function LDKPayee_Clear_get_node_id(ptr: bigint): number {
11282 if(!isWasmInitialized) {
11283 throw new Error("initializeWasm() must be awaited first!");
11285 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_node_id(ptr);
11286 return nativeResponseValue;
11289 export function LDKPayee_Clear_get_route_hints(ptr: bigint): number {
11290 if(!isWasmInitialized) {
11291 throw new Error("initializeWasm() must be awaited first!");
11293 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_route_hints(ptr);
11294 return nativeResponseValue;
11297 export function LDKPayee_Clear_get_features(ptr: bigint): bigint {
11298 if(!isWasmInitialized) {
11299 throw new Error("initializeWasm() must be awaited first!");
11301 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_features(ptr);
11302 return nativeResponseValue;
11305 export function LDKPayee_Clear_get_final_cltv_expiry_delta(ptr: bigint): number {
11306 if(!isWasmInitialized) {
11307 throw new Error("initializeWasm() must be awaited first!");
11309 const nativeResponseValue = wasm.TS_LDKPayee_Clear_get_final_cltv_expiry_delta(ptr);
11310 return nativeResponseValue;
11313 export interface LDKScore {
11318 export function LDKScore_new(impl: LDKScore, ScoreLookUp: number, ScoreUpdate: number): [bigint, number] {
11319 if(!isWasmInitialized) {
11320 throw new Error("initializeWasm() must be awaited first!");
11322 var new_obj_idx = js_objs.length;
11323 for (var i = 0; i < js_objs.length; i++) {
11324 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11326 js_objs[i] = new WeakRef(impl);
11327 return [wasm.TS_LDKScore_new(i, ScoreLookUp, ScoreUpdate), i];
11329 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
11331 export function Score_write(this_arg: bigint): number {
11332 if(!isWasmInitialized) {
11333 throw new Error("initializeWasm() must be awaited first!");
11335 const nativeResponseValue = wasm.TS_Score_write(this_arg);
11336 return nativeResponseValue;
11339 export interface LDKCoinSelectionSource {
11340 select_confirmed_utxos (claim_id: number, must_spend: number, must_pay_to: number, target_feerate_sat_per_1000_weight: number): bigint;
11341 sign_psbt (psbt: number): bigint;
11345 export function LDKCoinSelectionSource_new(impl: LDKCoinSelectionSource): [bigint, number] {
11346 if(!isWasmInitialized) {
11347 throw new Error("initializeWasm() must be awaited first!");
11349 var new_obj_idx = js_objs.length;
11350 for (var i = 0; i < js_objs.length; i++) {
11351 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11353 js_objs[i] = new WeakRef(impl);
11354 return [wasm.TS_LDKCoinSelectionSource_new(i), i];
11356 // 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
11358 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 {
11359 if(!isWasmInitialized) {
11360 throw new Error("initializeWasm() must be awaited first!");
11362 const nativeResponseValue = wasm.TS_CoinSelectionSource_select_confirmed_utxos(this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
11363 return nativeResponseValue;
11365 // LDKCResult_TransactionNoneZ CoinSelectionSource_sign_psbt LDKCoinSelectionSource *NONNULL_PTR this_arg, struct LDKCVec_u8Z psbt
11367 export function CoinSelectionSource_sign_psbt(this_arg: bigint, psbt: number): bigint {
11368 if(!isWasmInitialized) {
11369 throw new Error("initializeWasm() must be awaited first!");
11371 const nativeResponseValue = wasm.TS_CoinSelectionSource_sign_psbt(this_arg, psbt);
11372 return nativeResponseValue;
11375 export interface LDKWalletSource {
11376 list_confirmed_utxos (): bigint;
11377 get_change_script (): bigint;
11378 sign_psbt (psbt: number): bigint;
11382 export function LDKWalletSource_new(impl: LDKWalletSource): [bigint, number] {
11383 if(!isWasmInitialized) {
11384 throw new Error("initializeWasm() must be awaited first!");
11386 var new_obj_idx = js_objs.length;
11387 for (var i = 0; i < js_objs.length; i++) {
11388 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
11390 js_objs[i] = new WeakRef(impl);
11391 return [wasm.TS_LDKWalletSource_new(i), i];
11393 // LDKCResult_CVec_UtxoZNoneZ WalletSource_list_confirmed_utxos LDKWalletSource *NONNULL_PTR this_arg
11395 export function WalletSource_list_confirmed_utxos(this_arg: bigint): bigint {
11396 if(!isWasmInitialized) {
11397 throw new Error("initializeWasm() must be awaited first!");
11399 const nativeResponseValue = wasm.TS_WalletSource_list_confirmed_utxos(this_arg);
11400 return nativeResponseValue;
11402 // LDKCResult_CVec_u8ZNoneZ WalletSource_get_change_script LDKWalletSource *NONNULL_PTR this_arg
11404 export function WalletSource_get_change_script(this_arg: bigint): bigint {
11405 if(!isWasmInitialized) {
11406 throw new Error("initializeWasm() must be awaited first!");
11408 const nativeResponseValue = wasm.TS_WalletSource_get_change_script(this_arg);
11409 return nativeResponseValue;
11411 // LDKCResult_TransactionNoneZ WalletSource_sign_psbt LDKWalletSource *NONNULL_PTR this_arg, struct LDKCVec_u8Z psbt
11413 export function WalletSource_sign_psbt(this_arg: bigint, psbt: number): bigint {
11414 if(!isWasmInitialized) {
11415 throw new Error("initializeWasm() must be awaited first!");
11417 const nativeResponseValue = wasm.TS_WalletSource_sign_psbt(this_arg, psbt);
11418 return nativeResponseValue;
11421 export class LDKGossipSync {
11422 protected constructor() {}
11425 export function LDKGossipSync_ty_from_ptr(ptr: bigint): number {
11426 if(!isWasmInitialized) {
11427 throw new Error("initializeWasm() must be awaited first!");
11429 const nativeResponseValue = wasm.TS_LDKGossipSync_ty_from_ptr(ptr);
11430 return nativeResponseValue;
11433 export function LDKGossipSync_P2P_get_p2p(ptr: bigint): bigint {
11434 if(!isWasmInitialized) {
11435 throw new Error("initializeWasm() must be awaited first!");
11437 const nativeResponseValue = wasm.TS_LDKGossipSync_P2P_get_p2p(ptr);
11438 return nativeResponseValue;
11441 export function LDKGossipSync_Rapid_get_rapid(ptr: bigint): bigint {
11442 if(!isWasmInitialized) {
11443 throw new Error("initializeWasm() must be awaited first!");
11445 const nativeResponseValue = wasm.TS_LDKGossipSync_Rapid_get_rapid(ptr);
11446 return nativeResponseValue;
11449 export class LDKFallback {
11450 protected constructor() {}
11453 export function LDKFallback_ty_from_ptr(ptr: bigint): number {
11454 if(!isWasmInitialized) {
11455 throw new Error("initializeWasm() must be awaited first!");
11457 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
11458 return nativeResponseValue;
11461 export function LDKFallback_SegWitProgram_get_version(ptr: bigint): number {
11462 if(!isWasmInitialized) {
11463 throw new Error("initializeWasm() must be awaited first!");
11465 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
11466 return nativeResponseValue;
11469 export function LDKFallback_SegWitProgram_get_program(ptr: bigint): number {
11470 if(!isWasmInitialized) {
11471 throw new Error("initializeWasm() must be awaited first!");
11473 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
11474 return nativeResponseValue;
11477 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: bigint): number {
11478 if(!isWasmInitialized) {
11479 throw new Error("initializeWasm() must be awaited first!");
11481 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
11482 return nativeResponseValue;
11485 export function LDKFallback_ScriptHash_get_script_hash(ptr: bigint): number {
11486 if(!isWasmInitialized) {
11487 throw new Error("initializeWasm() must be awaited first!");
11489 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
11490 return nativeResponseValue;
11492 // struct LDKStr _ldk_get_compiled_version(void);
11494 export function _ldk_get_compiled_version(): number {
11495 if(!isWasmInitialized) {
11496 throw new Error("initializeWasm() must be awaited first!");
11498 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
11499 return nativeResponseValue;
11501 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
11503 export function _ldk_c_bindings_get_compiled_version(): number {
11504 if(!isWasmInitialized) {
11505 throw new Error("initializeWasm() must be awaited first!");
11507 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
11508 return nativeResponseValue;
11510 // struct LDKSixteenBytes U128_le_bytes(struct LDKU128 val);
11512 export function U128_le_bytes(val: number): number {
11513 if(!isWasmInitialized) {
11514 throw new Error("initializeWasm() must be awaited first!");
11516 const nativeResponseValue = wasm.TS_U128_le_bytes(val);
11517 return nativeResponseValue;
11519 // struct LDKU128 U128_new(struct LDKSixteenBytes le_bytes);
11521 export function U128_new(le_bytes: number): number {
11522 if(!isWasmInitialized) {
11523 throw new Error("initializeWasm() must be awaited first!");
11525 const nativeResponseValue = wasm.TS_U128_new(le_bytes);
11526 return nativeResponseValue;
11528 // struct LDKWitnessProgram WitnessProgram_new(struct LDKWitnessVersion version, struct LDKCVec_u8Z program);
11530 export function WitnessProgram_new(version: number, program: number): bigint {
11531 if(!isWasmInitialized) {
11532 throw new Error("initializeWasm() must be awaited first!");
11534 const nativeResponseValue = wasm.TS_WitnessProgram_new(version, program);
11535 return nativeResponseValue;
11537 // struct LDKWitnessVersion WitnessProgram_get_version(const struct LDKWitnessProgram *NONNULL_PTR prog);
11539 export function WitnessProgram_get_version(prog: bigint): number {
11540 if(!isWasmInitialized) {
11541 throw new Error("initializeWasm() must be awaited first!");
11543 const nativeResponseValue = wasm.TS_WitnessProgram_get_version(prog);
11544 return nativeResponseValue;
11546 // struct LDKu8slice WitnessProgram_get_program(const struct LDKWitnessProgram *NONNULL_PTR prog);
11548 export function WitnessProgram_get_program(prog: bigint): number {
11549 if(!isWasmInitialized) {
11550 throw new Error("initializeWasm() must be awaited first!");
11552 const nativeResponseValue = wasm.TS_WitnessProgram_get_program(prog);
11553 return nativeResponseValue;
11555 // uint64_t WitnessProgram_clone_ptr(LDKWitnessProgram *NONNULL_PTR arg);
11557 export function WitnessProgram_clone_ptr(arg: bigint): bigint {
11558 if(!isWasmInitialized) {
11559 throw new Error("initializeWasm() must be awaited first!");
11561 const nativeResponseValue = wasm.TS_WitnessProgram_clone_ptr(arg);
11562 return nativeResponseValue;
11564 // struct LDKWitnessProgram WitnessProgram_clone(const struct LDKWitnessProgram *NONNULL_PTR orig);
11566 export function WitnessProgram_clone(orig: bigint): bigint {
11567 if(!isWasmInitialized) {
11568 throw new Error("initializeWasm() must be awaited first!");
11570 const nativeResponseValue = wasm.TS_WitnessProgram_clone(orig);
11571 return nativeResponseValue;
11573 // void WitnessProgram_free(struct LDKWitnessProgram o);
11575 export function WitnessProgram_free(o: bigint): void {
11576 if(!isWasmInitialized) {
11577 throw new Error("initializeWasm() must be awaited first!");
11579 const nativeResponseValue = wasm.TS_WitnessProgram_free(o);
11580 // debug statements here
11582 // struct LDKBigEndianScalar BigEndianScalar_new(struct LDKThirtyTwoBytes big_endian_bytes);
11584 export function BigEndianScalar_new(big_endian_bytes: number): bigint {
11585 if(!isWasmInitialized) {
11586 throw new Error("initializeWasm() must be awaited first!");
11588 const nativeResponseValue = wasm.TS_BigEndianScalar_new(big_endian_bytes);
11589 return nativeResponseValue;
11591 // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
11593 export function Bech32Error_clone_ptr(arg: bigint): bigint {
11594 if(!isWasmInitialized) {
11595 throw new Error("initializeWasm() must be awaited first!");
11597 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
11598 return nativeResponseValue;
11600 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
11602 export function Bech32Error_clone(orig: bigint): bigint {
11603 if(!isWasmInitialized) {
11604 throw new Error("initializeWasm() must be awaited first!");
11606 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
11607 return nativeResponseValue;
11609 // void Bech32Error_free(struct LDKBech32Error o);
11611 export function Bech32Error_free(o: bigint): void {
11612 if(!isWasmInitialized) {
11613 throw new Error("initializeWasm() must be awaited first!");
11615 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
11616 // debug statements here
11618 // void Transaction_free(struct LDKTransaction _res);
11620 export function Transaction_free(_res: number): void {
11621 if(!isWasmInitialized) {
11622 throw new Error("initializeWasm() must be awaited first!");
11624 const nativeResponseValue = wasm.TS_Transaction_free(_res);
11625 // debug statements here
11627 // void Witness_free(struct LDKWitness _res);
11629 export function Witness_free(_res: number): void {
11630 if(!isWasmInitialized) {
11631 throw new Error("initializeWasm() must be awaited first!");
11633 const nativeResponseValue = wasm.TS_Witness_free(_res);
11634 // debug statements here
11636 // struct LDKTxIn TxIn_new(struct LDKWitness witness, struct LDKCVec_u8Z script_sig, uint32_t sequence, struct LDKThirtyTwoBytes previous_txid, uint32_t previous_vout);
11638 export function TxIn_new(witness: number, script_sig: number, sequence: number, previous_txid: number, previous_vout: number): bigint {
11639 if(!isWasmInitialized) {
11640 throw new Error("initializeWasm() must be awaited first!");
11642 const nativeResponseValue = wasm.TS_TxIn_new(witness, script_sig, sequence, previous_txid, previous_vout);
11643 return nativeResponseValue;
11645 // struct LDKWitness TxIn_get_witness(const struct LDKTxIn *NONNULL_PTR txin);
11647 export function TxIn_get_witness(txin: bigint): number {
11648 if(!isWasmInitialized) {
11649 throw new Error("initializeWasm() must be awaited first!");
11651 const nativeResponseValue = wasm.TS_TxIn_get_witness(txin);
11652 return nativeResponseValue;
11654 // struct LDKu8slice TxIn_get_script_sig(const struct LDKTxIn *NONNULL_PTR txin);
11656 export function TxIn_get_script_sig(txin: bigint): number {
11657 if(!isWasmInitialized) {
11658 throw new Error("initializeWasm() must be awaited first!");
11660 const nativeResponseValue = wasm.TS_TxIn_get_script_sig(txin);
11661 return nativeResponseValue;
11663 // uint32_t TxIn_get_sequence(const struct LDKTxIn *NONNULL_PTR txin);
11665 export function TxIn_get_sequence(txin: bigint): number {
11666 if(!isWasmInitialized) {
11667 throw new Error("initializeWasm() must be awaited first!");
11669 const nativeResponseValue = wasm.TS_TxIn_get_sequence(txin);
11670 return nativeResponseValue;
11672 // struct LDKThirtyTwoBytes TxIn_get_previous_txid(const struct LDKTxIn *NONNULL_PTR txin);
11674 export function TxIn_get_previous_txid(txin: bigint): number {
11675 if(!isWasmInitialized) {
11676 throw new Error("initializeWasm() must be awaited first!");
11678 const nativeResponseValue = wasm.TS_TxIn_get_previous_txid(txin);
11679 return nativeResponseValue;
11681 // uint32_t TxIn_get_previous_vout(const struct LDKTxIn *NONNULL_PTR txin);
11683 export function TxIn_get_previous_vout(txin: bigint): number {
11684 if(!isWasmInitialized) {
11685 throw new Error("initializeWasm() must be awaited first!");
11687 const nativeResponseValue = wasm.TS_TxIn_get_previous_vout(txin);
11688 return nativeResponseValue;
11690 // void TxIn_free(struct LDKTxIn _res);
11692 export function TxIn_free(_res: bigint): void {
11693 if(!isWasmInitialized) {
11694 throw new Error("initializeWasm() must be awaited first!");
11696 const nativeResponseValue = wasm.TS_TxIn_free(_res);
11697 // debug statements here
11699 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
11701 export function TxOut_new(script_pubkey: number, value: bigint): bigint {
11702 if(!isWasmInitialized) {
11703 throw new Error("initializeWasm() must be awaited first!");
11705 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
11706 return nativeResponseValue;
11708 // struct LDKu8slice TxOut_get_script_pubkey(const struct LDKTxOut *NONNULL_PTR txout);
11710 export function TxOut_get_script_pubkey(txout: bigint): number {
11711 if(!isWasmInitialized) {
11712 throw new Error("initializeWasm() must be awaited first!");
11714 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(txout);
11715 return nativeResponseValue;
11717 // uint64_t TxOut_get_value(const struct LDKTxOut *NONNULL_PTR txout);
11719 export function TxOut_get_value(txout: bigint): bigint {
11720 if(!isWasmInitialized) {
11721 throw new Error("initializeWasm() must be awaited first!");
11723 const nativeResponseValue = wasm.TS_TxOut_get_value(txout);
11724 return nativeResponseValue;
11726 // void TxOut_free(struct LDKTxOut _res);
11728 export function TxOut_free(_res: bigint): void {
11729 if(!isWasmInitialized) {
11730 throw new Error("initializeWasm() must be awaited first!");
11732 const nativeResponseValue = wasm.TS_TxOut_free(_res);
11733 // debug statements here
11735 // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
11737 export function TxOut_clone_ptr(arg: bigint): bigint {
11738 if(!isWasmInitialized) {
11739 throw new Error("initializeWasm() must be awaited first!");
11741 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
11742 return nativeResponseValue;
11744 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
11746 export function TxOut_clone(orig: bigint): bigint {
11747 if(!isWasmInitialized) {
11748 throw new Error("initializeWasm() must be awaited first!");
11750 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
11751 return nativeResponseValue;
11753 // void Str_free(struct LDKStr _res);
11755 export function Str_free(_res: number): void {
11756 if(!isWasmInitialized) {
11757 throw new Error("initializeWasm() must be awaited first!");
11759 const nativeResponseValue = wasm.TS_Str_free(_res);
11760 // debug statements here
11762 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
11764 export function COption_u64Z_some(o: bigint): bigint {
11765 if(!isWasmInitialized) {
11766 throw new Error("initializeWasm() must be awaited first!");
11768 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
11769 return nativeResponseValue;
11771 // struct LDKCOption_u64Z COption_u64Z_none(void);
11773 export function COption_u64Z_none(): bigint {
11774 if(!isWasmInitialized) {
11775 throw new Error("initializeWasm() must be awaited first!");
11777 const nativeResponseValue = wasm.TS_COption_u64Z_none();
11778 return nativeResponseValue;
11780 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
11782 export function COption_u64Z_free(_res: bigint): void {
11783 if(!isWasmInitialized) {
11784 throw new Error("initializeWasm() must be awaited first!");
11786 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
11787 // debug statements here
11789 // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
11791 export function COption_u64Z_clone_ptr(arg: bigint): bigint {
11792 if(!isWasmInitialized) {
11793 throw new Error("initializeWasm() must be awaited first!");
11795 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
11796 return nativeResponseValue;
11798 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
11800 export function COption_u64Z_clone(orig: bigint): bigint {
11801 if(!isWasmInitialized) {
11802 throw new Error("initializeWasm() must be awaited first!");
11804 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
11805 return nativeResponseValue;
11807 // void CVec_BlindedPathZ_free(struct LDKCVec_BlindedPathZ _res);
11809 export function CVec_BlindedPathZ_free(_res: number): void {
11810 if(!isWasmInitialized) {
11811 throw new Error("initializeWasm() must be awaited first!");
11813 const nativeResponseValue = wasm.TS_CVec_BlindedPathZ_free(_res);
11814 // debug statements here
11816 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_ok(struct LDKRefund o);
11818 export function CResult_RefundBolt12ParseErrorZ_ok(o: bigint): bigint {
11819 if(!isWasmInitialized) {
11820 throw new Error("initializeWasm() must be awaited first!");
11822 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_ok(o);
11823 return nativeResponseValue;
11825 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
11827 export function CResult_RefundBolt12ParseErrorZ_err(e: bigint): bigint {
11828 if(!isWasmInitialized) {
11829 throw new Error("initializeWasm() must be awaited first!");
11831 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_err(e);
11832 return nativeResponseValue;
11834 // bool CResult_RefundBolt12ParseErrorZ_is_ok(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR o);
11836 export function CResult_RefundBolt12ParseErrorZ_is_ok(o: bigint): boolean {
11837 if(!isWasmInitialized) {
11838 throw new Error("initializeWasm() must be awaited first!");
11840 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_is_ok(o);
11841 return nativeResponseValue;
11843 // void CResult_RefundBolt12ParseErrorZ_free(struct LDKCResult_RefundBolt12ParseErrorZ _res);
11845 export function CResult_RefundBolt12ParseErrorZ_free(_res: bigint): void {
11846 if(!isWasmInitialized) {
11847 throw new Error("initializeWasm() must be awaited first!");
11849 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_free(_res);
11850 // debug statements here
11852 // uint64_t CResult_RefundBolt12ParseErrorZ_clone_ptr(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR arg);
11854 export function CResult_RefundBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
11855 if(!isWasmInitialized) {
11856 throw new Error("initializeWasm() must be awaited first!");
11858 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone_ptr(arg);
11859 return nativeResponseValue;
11861 // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_clone(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR orig);
11863 export function CResult_RefundBolt12ParseErrorZ_clone(orig: bigint): bigint {
11864 if(!isWasmInitialized) {
11865 throw new Error("initializeWasm() must be awaited first!");
11867 const nativeResponseValue = wasm.TS_CResult_RefundBolt12ParseErrorZ_clone(orig);
11868 return nativeResponseValue;
11870 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_ok(struct LDKRetry o);
11872 export function CResult_RetryDecodeErrorZ_ok(o: bigint): bigint {
11873 if(!isWasmInitialized) {
11874 throw new Error("initializeWasm() must be awaited first!");
11876 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_ok(o);
11877 return nativeResponseValue;
11879 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_err(struct LDKDecodeError e);
11881 export function CResult_RetryDecodeErrorZ_err(e: bigint): bigint {
11882 if(!isWasmInitialized) {
11883 throw new Error("initializeWasm() must be awaited first!");
11885 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_err(e);
11886 return nativeResponseValue;
11888 // bool CResult_RetryDecodeErrorZ_is_ok(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR o);
11890 export function CResult_RetryDecodeErrorZ_is_ok(o: bigint): boolean {
11891 if(!isWasmInitialized) {
11892 throw new Error("initializeWasm() must be awaited first!");
11894 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_is_ok(o);
11895 return nativeResponseValue;
11897 // void CResult_RetryDecodeErrorZ_free(struct LDKCResult_RetryDecodeErrorZ _res);
11899 export function CResult_RetryDecodeErrorZ_free(_res: bigint): void {
11900 if(!isWasmInitialized) {
11901 throw new Error("initializeWasm() must be awaited first!");
11903 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_free(_res);
11904 // debug statements here
11906 // uint64_t CResult_RetryDecodeErrorZ_clone_ptr(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR arg);
11908 export function CResult_RetryDecodeErrorZ_clone_ptr(arg: bigint): bigint {
11909 if(!isWasmInitialized) {
11910 throw new Error("initializeWasm() must be awaited first!");
11912 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_clone_ptr(arg);
11913 return nativeResponseValue;
11915 // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_clone(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR orig);
11917 export function CResult_RetryDecodeErrorZ_clone(orig: bigint): bigint {
11918 if(!isWasmInitialized) {
11919 throw new Error("initializeWasm() must be awaited first!");
11921 const nativeResponseValue = wasm.TS_CResult_RetryDecodeErrorZ_clone(orig);
11922 return nativeResponseValue;
11924 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
11926 export function CResult_NoneAPIErrorZ_ok(): bigint {
11927 if(!isWasmInitialized) {
11928 throw new Error("initializeWasm() must be awaited first!");
11930 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
11931 return nativeResponseValue;
11933 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
11935 export function CResult_NoneAPIErrorZ_err(e: bigint): bigint {
11936 if(!isWasmInitialized) {
11937 throw new Error("initializeWasm() must be awaited first!");
11939 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
11940 return nativeResponseValue;
11942 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
11944 export function CResult_NoneAPIErrorZ_is_ok(o: bigint): boolean {
11945 if(!isWasmInitialized) {
11946 throw new Error("initializeWasm() must be awaited first!");
11948 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
11949 return nativeResponseValue;
11951 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
11953 export function CResult_NoneAPIErrorZ_free(_res: bigint): void {
11954 if(!isWasmInitialized) {
11955 throw new Error("initializeWasm() must be awaited first!");
11957 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
11958 // debug statements here
11960 // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
11962 export function CResult_NoneAPIErrorZ_clone_ptr(arg: bigint): bigint {
11963 if(!isWasmInitialized) {
11964 throw new Error("initializeWasm() must be awaited first!");
11966 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
11967 return nativeResponseValue;
11969 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
11971 export function CResult_NoneAPIErrorZ_clone(orig: bigint): bigint {
11972 if(!isWasmInitialized) {
11973 throw new Error("initializeWasm() must be awaited first!");
11975 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
11976 return nativeResponseValue;
11978 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
11980 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
11981 if(!isWasmInitialized) {
11982 throw new Error("initializeWasm() must be awaited first!");
11984 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
11985 // debug statements here
11987 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
11989 export function CVec_APIErrorZ_free(_res: number): void {
11990 if(!isWasmInitialized) {
11991 throw new Error("initializeWasm() must be awaited first!");
11993 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
11994 // debug statements here
11996 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_some(struct LDKThirtyTwoBytes o);
11998 export function COption_ThirtyTwoBytesZ_some(o: number): bigint {
11999 if(!isWasmInitialized) {
12000 throw new Error("initializeWasm() must be awaited first!");
12002 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_some(o);
12003 return nativeResponseValue;
12005 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_none(void);
12007 export function COption_ThirtyTwoBytesZ_none(): bigint {
12008 if(!isWasmInitialized) {
12009 throw new Error("initializeWasm() must be awaited first!");
12011 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_none();
12012 return nativeResponseValue;
12014 // void COption_ThirtyTwoBytesZ_free(struct LDKCOption_ThirtyTwoBytesZ _res);
12016 export function COption_ThirtyTwoBytesZ_free(_res: bigint): void {
12017 if(!isWasmInitialized) {
12018 throw new Error("initializeWasm() must be awaited first!");
12020 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_free(_res);
12021 // debug statements here
12023 // uint64_t COption_ThirtyTwoBytesZ_clone_ptr(LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR arg);
12025 export function COption_ThirtyTwoBytesZ_clone_ptr(arg: bigint): bigint {
12026 if(!isWasmInitialized) {
12027 throw new Error("initializeWasm() must be awaited first!");
12029 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_clone_ptr(arg);
12030 return nativeResponseValue;
12032 // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_clone(const struct LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR orig);
12034 export function COption_ThirtyTwoBytesZ_clone(orig: bigint): bigint {
12035 if(!isWasmInitialized) {
12036 throw new Error("initializeWasm() must be awaited first!");
12038 const nativeResponseValue = wasm.TS_COption_ThirtyTwoBytesZ_clone(orig);
12039 return nativeResponseValue;
12041 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
12043 export function CVec_u8Z_free(_res: number): void {
12044 if(!isWasmInitialized) {
12045 throw new Error("initializeWasm() must be awaited first!");
12047 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
12048 // debug statements here
12050 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_some(struct LDKCVec_u8Z o);
12052 export function COption_CVec_u8ZZ_some(o: number): bigint {
12053 if(!isWasmInitialized) {
12054 throw new Error("initializeWasm() must be awaited first!");
12056 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_some(o);
12057 return nativeResponseValue;
12059 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_none(void);
12061 export function COption_CVec_u8ZZ_none(): bigint {
12062 if(!isWasmInitialized) {
12063 throw new Error("initializeWasm() must be awaited first!");
12065 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_none();
12066 return nativeResponseValue;
12068 // void COption_CVec_u8ZZ_free(struct LDKCOption_CVec_u8ZZ _res);
12070 export function COption_CVec_u8ZZ_free(_res: bigint): void {
12071 if(!isWasmInitialized) {
12072 throw new Error("initializeWasm() must be awaited first!");
12074 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_free(_res);
12075 // debug statements here
12077 // uint64_t COption_CVec_u8ZZ_clone_ptr(LDKCOption_CVec_u8ZZ *NONNULL_PTR arg);
12079 export function COption_CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
12080 if(!isWasmInitialized) {
12081 throw new Error("initializeWasm() must be awaited first!");
12083 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone_ptr(arg);
12084 return nativeResponseValue;
12086 // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_clone(const struct LDKCOption_CVec_u8ZZ *NONNULL_PTR orig);
12088 export function COption_CVec_u8ZZ_clone(orig: bigint): bigint {
12089 if(!isWasmInitialized) {
12090 throw new Error("initializeWasm() must be awaited first!");
12092 const nativeResponseValue = wasm.TS_COption_CVec_u8ZZ_clone(orig);
12093 return nativeResponseValue;
12095 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_ok(struct LDKRecipientOnionFields o);
12097 export function CResult_RecipientOnionFieldsDecodeErrorZ_ok(o: bigint): bigint {
12098 if(!isWasmInitialized) {
12099 throw new Error("initializeWasm() must be awaited first!");
12101 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok(o);
12102 return nativeResponseValue;
12104 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_err(struct LDKDecodeError e);
12106 export function CResult_RecipientOnionFieldsDecodeErrorZ_err(e: bigint): bigint {
12107 if(!isWasmInitialized) {
12108 throw new Error("initializeWasm() must be awaited first!");
12110 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_err(e);
12111 return nativeResponseValue;
12113 // bool CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR o);
12115 export function CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o: bigint): boolean {
12116 if(!isWasmInitialized) {
12117 throw new Error("initializeWasm() must be awaited first!");
12119 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o);
12120 return nativeResponseValue;
12122 // void CResult_RecipientOnionFieldsDecodeErrorZ_free(struct LDKCResult_RecipientOnionFieldsDecodeErrorZ _res);
12124 export function CResult_RecipientOnionFieldsDecodeErrorZ_free(_res: bigint): void {
12125 if(!isWasmInitialized) {
12126 throw new Error("initializeWasm() must be awaited first!");
12128 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_free(_res);
12129 // debug statements here
12131 // uint64_t CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR arg);
12133 export function CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12134 if(!isWasmInitialized) {
12135 throw new Error("initializeWasm() must be awaited first!");
12137 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg);
12138 return nativeResponseValue;
12140 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_clone(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR orig);
12142 export function CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig: bigint): bigint {
12143 if(!isWasmInitialized) {
12144 throw new Error("initializeWasm() must be awaited first!");
12146 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig);
12147 return nativeResponseValue;
12149 // uint64_t C2Tuple_u64CVec_u8ZZ_clone_ptr(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR arg);
12151 export function C2Tuple_u64CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
12152 if(!isWasmInitialized) {
12153 throw new Error("initializeWasm() must be awaited first!");
12155 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_clone_ptr(arg);
12156 return nativeResponseValue;
12158 // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_clone(const struct LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR orig);
12160 export function C2Tuple_u64CVec_u8ZZ_clone(orig: bigint): bigint {
12161 if(!isWasmInitialized) {
12162 throw new Error("initializeWasm() must be awaited first!");
12164 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_clone(orig);
12165 return nativeResponseValue;
12167 // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_new(uint64_t a, struct LDKCVec_u8Z b);
12169 export function C2Tuple_u64CVec_u8ZZ_new(a: bigint, b: number): bigint {
12170 if(!isWasmInitialized) {
12171 throw new Error("initializeWasm() must be awaited first!");
12173 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_new(a, b);
12174 return nativeResponseValue;
12176 // void C2Tuple_u64CVec_u8ZZ_free(struct LDKC2Tuple_u64CVec_u8ZZ _res);
12178 export function C2Tuple_u64CVec_u8ZZ_free(_res: bigint): void {
12179 if(!isWasmInitialized) {
12180 throw new Error("initializeWasm() must be awaited first!");
12182 const nativeResponseValue = wasm.TS_C2Tuple_u64CVec_u8ZZ_free(_res);
12183 // debug statements here
12185 // void CVec_C2Tuple_u64CVec_u8ZZZ_free(struct LDKCVec_C2Tuple_u64CVec_u8ZZZ _res);
12187 export function CVec_C2Tuple_u64CVec_u8ZZZ_free(_res: number): void {
12188 if(!isWasmInitialized) {
12189 throw new Error("initializeWasm() must be awaited first!");
12191 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u64CVec_u8ZZZ_free(_res);
12192 // debug statements here
12194 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_ok(struct LDKRecipientOnionFields o);
12196 export function CResult_RecipientOnionFieldsNoneZ_ok(o: bigint): bigint {
12197 if(!isWasmInitialized) {
12198 throw new Error("initializeWasm() must be awaited first!");
12200 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_ok(o);
12201 return nativeResponseValue;
12203 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_err(void);
12205 export function CResult_RecipientOnionFieldsNoneZ_err(): bigint {
12206 if(!isWasmInitialized) {
12207 throw new Error("initializeWasm() must be awaited first!");
12209 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_err();
12210 return nativeResponseValue;
12212 // bool CResult_RecipientOnionFieldsNoneZ_is_ok(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR o);
12214 export function CResult_RecipientOnionFieldsNoneZ_is_ok(o: bigint): boolean {
12215 if(!isWasmInitialized) {
12216 throw new Error("initializeWasm() must be awaited first!");
12218 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_is_ok(o);
12219 return nativeResponseValue;
12221 // void CResult_RecipientOnionFieldsNoneZ_free(struct LDKCResult_RecipientOnionFieldsNoneZ _res);
12223 export function CResult_RecipientOnionFieldsNoneZ_free(_res: bigint): void {
12224 if(!isWasmInitialized) {
12225 throw new Error("initializeWasm() must be awaited first!");
12227 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_free(_res);
12228 // debug statements here
12230 // uint64_t CResult_RecipientOnionFieldsNoneZ_clone_ptr(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR arg);
12232 export function CResult_RecipientOnionFieldsNoneZ_clone_ptr(arg: bigint): bigint {
12233 if(!isWasmInitialized) {
12234 throw new Error("initializeWasm() must be awaited first!");
12236 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_clone_ptr(arg);
12237 return nativeResponseValue;
12239 // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_clone(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR orig);
12241 export function CResult_RecipientOnionFieldsNoneZ_clone(orig: bigint): bigint {
12242 if(!isWasmInitialized) {
12243 throw new Error("initializeWasm() must be awaited first!");
12245 const nativeResponseValue = wasm.TS_CResult_RecipientOnionFieldsNoneZ_clone(orig);
12246 return nativeResponseValue;
12248 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
12250 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
12251 if(!isWasmInitialized) {
12252 throw new Error("initializeWasm() must be awaited first!");
12254 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
12255 // debug statements here
12257 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_some(struct LDKCVec_ThirtyTwoBytesZ o);
12259 export function COption_CVec_ThirtyTwoBytesZZ_some(o: number): bigint {
12260 if(!isWasmInitialized) {
12261 throw new Error("initializeWasm() must be awaited first!");
12263 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_some(o);
12264 return nativeResponseValue;
12266 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_none(void);
12268 export function COption_CVec_ThirtyTwoBytesZZ_none(): bigint {
12269 if(!isWasmInitialized) {
12270 throw new Error("initializeWasm() must be awaited first!");
12272 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_none();
12273 return nativeResponseValue;
12275 // void COption_CVec_ThirtyTwoBytesZZ_free(struct LDKCOption_CVec_ThirtyTwoBytesZZ _res);
12277 export function COption_CVec_ThirtyTwoBytesZZ_free(_res: bigint): void {
12278 if(!isWasmInitialized) {
12279 throw new Error("initializeWasm() must be awaited first!");
12281 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_free(_res);
12282 // debug statements here
12284 // uint64_t COption_CVec_ThirtyTwoBytesZZ_clone_ptr(LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR arg);
12286 export function COption_CVec_ThirtyTwoBytesZZ_clone_ptr(arg: bigint): bigint {
12287 if(!isWasmInitialized) {
12288 throw new Error("initializeWasm() must be awaited first!");
12290 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_clone_ptr(arg);
12291 return nativeResponseValue;
12293 // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_clone(const struct LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR orig);
12295 export function COption_CVec_ThirtyTwoBytesZZ_clone(orig: bigint): bigint {
12296 if(!isWasmInitialized) {
12297 throw new Error("initializeWasm() must be awaited first!");
12299 const nativeResponseValue = wasm.TS_COption_CVec_ThirtyTwoBytesZZ_clone(orig);
12300 return nativeResponseValue;
12302 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_ok(struct LDKThirtyTwoBytes o);
12304 export function CResult_ThirtyTwoBytesNoneZ_ok(o: number): bigint {
12305 if(!isWasmInitialized) {
12306 throw new Error("initializeWasm() must be awaited first!");
12308 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_ok(o);
12309 return nativeResponseValue;
12311 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_err(void);
12313 export function CResult_ThirtyTwoBytesNoneZ_err(): bigint {
12314 if(!isWasmInitialized) {
12315 throw new Error("initializeWasm() must be awaited first!");
12317 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_err();
12318 return nativeResponseValue;
12320 // bool CResult_ThirtyTwoBytesNoneZ_is_ok(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR o);
12322 export function CResult_ThirtyTwoBytesNoneZ_is_ok(o: bigint): boolean {
12323 if(!isWasmInitialized) {
12324 throw new Error("initializeWasm() must be awaited first!");
12326 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_is_ok(o);
12327 return nativeResponseValue;
12329 // void CResult_ThirtyTwoBytesNoneZ_free(struct LDKCResult_ThirtyTwoBytesNoneZ _res);
12331 export function CResult_ThirtyTwoBytesNoneZ_free(_res: bigint): void {
12332 if(!isWasmInitialized) {
12333 throw new Error("initializeWasm() must be awaited first!");
12335 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_free(_res);
12336 // debug statements here
12338 // uint64_t CResult_ThirtyTwoBytesNoneZ_clone_ptr(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR arg);
12340 export function CResult_ThirtyTwoBytesNoneZ_clone_ptr(arg: bigint): bigint {
12341 if(!isWasmInitialized) {
12342 throw new Error("initializeWasm() must be awaited first!");
12344 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_clone_ptr(arg);
12345 return nativeResponseValue;
12347 // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_clone(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR orig);
12349 export function CResult_ThirtyTwoBytesNoneZ_clone(orig: bigint): bigint {
12350 if(!isWasmInitialized) {
12351 throw new Error("initializeWasm() must be awaited first!");
12353 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesNoneZ_clone(orig);
12354 return nativeResponseValue;
12356 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_ok(struct LDKBlindedPayInfo o);
12358 export function CResult_BlindedPayInfoDecodeErrorZ_ok(o: bigint): bigint {
12359 if(!isWasmInitialized) {
12360 throw new Error("initializeWasm() must be awaited first!");
12362 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_ok(o);
12363 return nativeResponseValue;
12365 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_err(struct LDKDecodeError e);
12367 export function CResult_BlindedPayInfoDecodeErrorZ_err(e: bigint): bigint {
12368 if(!isWasmInitialized) {
12369 throw new Error("initializeWasm() must be awaited first!");
12371 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_err(e);
12372 return nativeResponseValue;
12374 // bool CResult_BlindedPayInfoDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR o);
12376 export function CResult_BlindedPayInfoDecodeErrorZ_is_ok(o: bigint): boolean {
12377 if(!isWasmInitialized) {
12378 throw new Error("initializeWasm() must be awaited first!");
12380 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok(o);
12381 return nativeResponseValue;
12383 // void CResult_BlindedPayInfoDecodeErrorZ_free(struct LDKCResult_BlindedPayInfoDecodeErrorZ _res);
12385 export function CResult_BlindedPayInfoDecodeErrorZ_free(_res: bigint): void {
12386 if(!isWasmInitialized) {
12387 throw new Error("initializeWasm() must be awaited first!");
12389 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_free(_res);
12390 // debug statements here
12392 // uint64_t CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR arg);
12394 export function CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12395 if(!isWasmInitialized) {
12396 throw new Error("initializeWasm() must be awaited first!");
12398 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg);
12399 return nativeResponseValue;
12401 // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_clone(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR orig);
12403 export function CResult_BlindedPayInfoDecodeErrorZ_clone(orig: bigint): bigint {
12404 if(!isWasmInitialized) {
12405 throw new Error("initializeWasm() must be awaited first!");
12407 const nativeResponseValue = wasm.TS_CResult_BlindedPayInfoDecodeErrorZ_clone(orig);
12408 return nativeResponseValue;
12410 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
12412 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
12413 if(!isWasmInitialized) {
12414 throw new Error("initializeWasm() must be awaited first!");
12416 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
12417 return nativeResponseValue;
12419 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
12421 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
12422 if(!isWasmInitialized) {
12423 throw new Error("initializeWasm() must be awaited first!");
12425 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
12426 return nativeResponseValue;
12428 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
12430 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
12431 if(!isWasmInitialized) {
12432 throw new Error("initializeWasm() must be awaited first!");
12434 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
12435 return nativeResponseValue;
12437 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
12439 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
12440 if(!isWasmInitialized) {
12441 throw new Error("initializeWasm() must be awaited first!");
12443 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
12444 // debug statements here
12446 // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
12448 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12449 if(!isWasmInitialized) {
12450 throw new Error("initializeWasm() must be awaited first!");
12452 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
12453 return nativeResponseValue;
12455 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
12457 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
12458 if(!isWasmInitialized) {
12459 throw new Error("initializeWasm() must be awaited first!");
12461 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
12462 return nativeResponseValue;
12464 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
12466 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
12467 if(!isWasmInitialized) {
12468 throw new Error("initializeWasm() must be awaited first!");
12470 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
12471 return nativeResponseValue;
12473 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
12475 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
12476 if(!isWasmInitialized) {
12477 throw new Error("initializeWasm() must be awaited first!");
12479 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
12480 return nativeResponseValue;
12482 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
12484 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
12485 if(!isWasmInitialized) {
12486 throw new Error("initializeWasm() must be awaited first!");
12488 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
12489 return nativeResponseValue;
12491 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
12493 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
12494 if(!isWasmInitialized) {
12495 throw new Error("initializeWasm() must be awaited first!");
12497 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
12498 // debug statements here
12500 // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
12502 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12503 if(!isWasmInitialized) {
12504 throw new Error("initializeWasm() must be awaited first!");
12506 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
12507 return nativeResponseValue;
12509 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
12511 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
12512 if(!isWasmInitialized) {
12513 throw new Error("initializeWasm() must be awaited first!");
12515 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
12516 return nativeResponseValue;
12518 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
12520 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: bigint): bigint {
12521 if(!isWasmInitialized) {
12522 throw new Error("initializeWasm() must be awaited first!");
12524 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
12525 return nativeResponseValue;
12527 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
12529 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: bigint): bigint {
12530 if(!isWasmInitialized) {
12531 throw new Error("initializeWasm() must be awaited first!");
12533 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
12534 return nativeResponseValue;
12536 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
12538 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
12539 if(!isWasmInitialized) {
12540 throw new Error("initializeWasm() must be awaited first!");
12542 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
12543 return nativeResponseValue;
12545 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
12547 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: bigint): void {
12548 if(!isWasmInitialized) {
12549 throw new Error("initializeWasm() must be awaited first!");
12551 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
12552 // debug statements here
12554 // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
12556 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12557 if(!isWasmInitialized) {
12558 throw new Error("initializeWasm() must be awaited first!");
12560 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
12561 return nativeResponseValue;
12563 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
12565 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
12566 if(!isWasmInitialized) {
12567 throw new Error("initializeWasm() must be awaited first!");
12569 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
12570 return nativeResponseValue;
12572 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
12574 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
12575 if(!isWasmInitialized) {
12576 throw new Error("initializeWasm() must be awaited first!");
12578 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
12579 // debug statements here
12581 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
12583 export function CVec_TxOutZ_free(_res: number): void {
12584 if(!isWasmInitialized) {
12585 throw new Error("initializeWasm() must be awaited first!");
12587 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
12588 // debug statements here
12590 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
12592 export function COption_u32Z_some(o: number): bigint {
12593 if(!isWasmInitialized) {
12594 throw new Error("initializeWasm() must be awaited first!");
12596 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
12597 return nativeResponseValue;
12599 // struct LDKCOption_u32Z COption_u32Z_none(void);
12601 export function COption_u32Z_none(): bigint {
12602 if(!isWasmInitialized) {
12603 throw new Error("initializeWasm() must be awaited first!");
12605 const nativeResponseValue = wasm.TS_COption_u32Z_none();
12606 return nativeResponseValue;
12608 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
12610 export function COption_u32Z_free(_res: bigint): void {
12611 if(!isWasmInitialized) {
12612 throw new Error("initializeWasm() must be awaited first!");
12614 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
12615 // debug statements here
12617 // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
12619 export function COption_u32Z_clone_ptr(arg: bigint): bigint {
12620 if(!isWasmInitialized) {
12621 throw new Error("initializeWasm() must be awaited first!");
12623 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
12624 return nativeResponseValue;
12626 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
12628 export function COption_u32Z_clone(orig: bigint): bigint {
12629 if(!isWasmInitialized) {
12630 throw new Error("initializeWasm() must be awaited first!");
12632 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
12633 return nativeResponseValue;
12635 // uint64_t C2Tuple_CVec_u8Zu64Z_clone_ptr(LDKC2Tuple_CVec_u8Zu64Z *NONNULL_PTR arg);
12637 export function C2Tuple_CVec_u8Zu64Z_clone_ptr(arg: bigint): bigint {
12638 if(!isWasmInitialized) {
12639 throw new Error("initializeWasm() must be awaited first!");
12641 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_clone_ptr(arg);
12642 return nativeResponseValue;
12644 // struct LDKC2Tuple_CVec_u8Zu64Z C2Tuple_CVec_u8Zu64Z_clone(const struct LDKC2Tuple_CVec_u8Zu64Z *NONNULL_PTR orig);
12646 export function C2Tuple_CVec_u8Zu64Z_clone(orig: bigint): bigint {
12647 if(!isWasmInitialized) {
12648 throw new Error("initializeWasm() must be awaited first!");
12650 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_clone(orig);
12651 return nativeResponseValue;
12653 // struct LDKC2Tuple_CVec_u8Zu64Z C2Tuple_CVec_u8Zu64Z_new(struct LDKCVec_u8Z a, uint64_t b);
12655 export function C2Tuple_CVec_u8Zu64Z_new(a: number, b: bigint): bigint {
12656 if(!isWasmInitialized) {
12657 throw new Error("initializeWasm() must be awaited first!");
12659 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_new(a, b);
12660 return nativeResponseValue;
12662 // void C2Tuple_CVec_u8Zu64Z_free(struct LDKC2Tuple_CVec_u8Zu64Z _res);
12664 export function C2Tuple_CVec_u8Zu64Z_free(_res: bigint): void {
12665 if(!isWasmInitialized) {
12666 throw new Error("initializeWasm() must be awaited first!");
12668 const nativeResponseValue = wasm.TS_C2Tuple_CVec_u8Zu64Z_free(_res);
12669 // debug statements here
12671 // struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ CResult_C2Tuple_CVec_u8Zu64ZNoneZ_ok(struct LDKC2Tuple_CVec_u8Zu64Z o);
12673 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_ok(o: bigint): bigint {
12674 if(!isWasmInitialized) {
12675 throw new Error("initializeWasm() must be awaited first!");
12677 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_ok(o);
12678 return nativeResponseValue;
12680 // struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ CResult_C2Tuple_CVec_u8Zu64ZNoneZ_err(void);
12682 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_err(): bigint {
12683 if(!isWasmInitialized) {
12684 throw new Error("initializeWasm() must be awaited first!");
12686 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_err();
12687 return nativeResponseValue;
12689 // bool CResult_C2Tuple_CVec_u8Zu64ZNoneZ_is_ok(const struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR o);
12691 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_is_ok(o: bigint): boolean {
12692 if(!isWasmInitialized) {
12693 throw new Error("initializeWasm() must be awaited first!");
12695 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_is_ok(o);
12696 return nativeResponseValue;
12698 // void CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ _res);
12700 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(_res: bigint): void {
12701 if(!isWasmInitialized) {
12702 throw new Error("initializeWasm() must be awaited first!");
12704 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(_res);
12705 // debug statements here
12707 // uint64_t CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone_ptr(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR arg);
12709 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone_ptr(arg: bigint): bigint {
12710 if(!isWasmInitialized) {
12711 throw new Error("initializeWasm() must be awaited first!");
12713 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone_ptr(arg);
12714 return nativeResponseValue;
12716 // struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone(const struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR orig);
12718 export function CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone(orig: bigint): bigint {
12719 if(!isWasmInitialized) {
12720 throw new Error("initializeWasm() must be awaited first!");
12722 const nativeResponseValue = wasm.TS_CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone(orig);
12723 return nativeResponseValue;
12725 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_ok(struct LDKChannelDerivationParameters o);
12727 export function CResult_ChannelDerivationParametersDecodeErrorZ_ok(o: bigint): bigint {
12728 if(!isWasmInitialized) {
12729 throw new Error("initializeWasm() must be awaited first!");
12731 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_ok(o);
12732 return nativeResponseValue;
12734 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_err(struct LDKDecodeError e);
12736 export function CResult_ChannelDerivationParametersDecodeErrorZ_err(e: bigint): bigint {
12737 if(!isWasmInitialized) {
12738 throw new Error("initializeWasm() must be awaited first!");
12740 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_err(e);
12741 return nativeResponseValue;
12743 // bool CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR o);
12745 export function CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(o: bigint): boolean {
12746 if(!isWasmInitialized) {
12747 throw new Error("initializeWasm() must be awaited first!");
12749 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(o);
12750 return nativeResponseValue;
12752 // void CResult_ChannelDerivationParametersDecodeErrorZ_free(struct LDKCResult_ChannelDerivationParametersDecodeErrorZ _res);
12754 export function CResult_ChannelDerivationParametersDecodeErrorZ_free(_res: bigint): void {
12755 if(!isWasmInitialized) {
12756 throw new Error("initializeWasm() must be awaited first!");
12758 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_free(_res);
12759 // debug statements here
12761 // uint64_t CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR arg);
12763 export function CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12764 if(!isWasmInitialized) {
12765 throw new Error("initializeWasm() must be awaited first!");
12767 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(arg);
12768 return nativeResponseValue;
12770 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR orig);
12772 export function CResult_ChannelDerivationParametersDecodeErrorZ_clone(orig: bigint): bigint {
12773 if(!isWasmInitialized) {
12774 throw new Error("initializeWasm() must be awaited first!");
12776 const nativeResponseValue = wasm.TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone(orig);
12777 return nativeResponseValue;
12779 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_ok(struct LDKHTLCDescriptor o);
12781 export function CResult_HTLCDescriptorDecodeErrorZ_ok(o: bigint): bigint {
12782 if(!isWasmInitialized) {
12783 throw new Error("initializeWasm() must be awaited first!");
12785 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_ok(o);
12786 return nativeResponseValue;
12788 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
12790 export function CResult_HTLCDescriptorDecodeErrorZ_err(e: bigint): bigint {
12791 if(!isWasmInitialized) {
12792 throw new Error("initializeWasm() must be awaited first!");
12794 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_err(e);
12795 return nativeResponseValue;
12797 // bool CResult_HTLCDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR o);
12799 export function CResult_HTLCDescriptorDecodeErrorZ_is_ok(o: bigint): boolean {
12800 if(!isWasmInitialized) {
12801 throw new Error("initializeWasm() must be awaited first!");
12803 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_is_ok(o);
12804 return nativeResponseValue;
12806 // void CResult_HTLCDescriptorDecodeErrorZ_free(struct LDKCResult_HTLCDescriptorDecodeErrorZ _res);
12808 export function CResult_HTLCDescriptorDecodeErrorZ_free(_res: bigint): void {
12809 if(!isWasmInitialized) {
12810 throw new Error("initializeWasm() must be awaited first!");
12812 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_free(_res);
12813 // debug statements here
12815 // uint64_t CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR arg);
12817 export function CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
12818 if(!isWasmInitialized) {
12819 throw new Error("initializeWasm() must be awaited first!");
12821 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(arg);
12822 return nativeResponseValue;
12824 // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_clone(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR orig);
12826 export function CResult_HTLCDescriptorDecodeErrorZ_clone(orig: bigint): bigint {
12827 if(!isWasmInitialized) {
12828 throw new Error("initializeWasm() must be awaited first!");
12830 const nativeResponseValue = wasm.TS_CResult_HTLCDescriptorDecodeErrorZ_clone(orig);
12831 return nativeResponseValue;
12833 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
12835 export function CResult_NoneNoneZ_ok(): bigint {
12836 if(!isWasmInitialized) {
12837 throw new Error("initializeWasm() must be awaited first!");
12839 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
12840 return nativeResponseValue;
12842 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
12844 export function CResult_NoneNoneZ_err(): bigint {
12845 if(!isWasmInitialized) {
12846 throw new Error("initializeWasm() must be awaited first!");
12848 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
12849 return nativeResponseValue;
12851 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
12853 export function CResult_NoneNoneZ_is_ok(o: bigint): boolean {
12854 if(!isWasmInitialized) {
12855 throw new Error("initializeWasm() must be awaited first!");
12857 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
12858 return nativeResponseValue;
12860 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
12862 export function CResult_NoneNoneZ_free(_res: bigint): void {
12863 if(!isWasmInitialized) {
12864 throw new Error("initializeWasm() must be awaited first!");
12866 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
12867 // debug statements here
12869 // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
12871 export function CResult_NoneNoneZ_clone_ptr(arg: bigint): bigint {
12872 if(!isWasmInitialized) {
12873 throw new Error("initializeWasm() must be awaited first!");
12875 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
12876 return nativeResponseValue;
12878 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
12880 export function CResult_NoneNoneZ_clone(orig: bigint): bigint {
12881 if(!isWasmInitialized) {
12882 throw new Error("initializeWasm() must be awaited first!");
12884 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
12885 return nativeResponseValue;
12887 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_ok(struct LDKPublicKey o);
12889 export function CResult_PublicKeyNoneZ_ok(o: number): bigint {
12890 if(!isWasmInitialized) {
12891 throw new Error("initializeWasm() must be awaited first!");
12893 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_ok(o);
12894 return nativeResponseValue;
12896 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_err(void);
12898 export function CResult_PublicKeyNoneZ_err(): bigint {
12899 if(!isWasmInitialized) {
12900 throw new Error("initializeWasm() must be awaited first!");
12902 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_err();
12903 return nativeResponseValue;
12905 // bool CResult_PublicKeyNoneZ_is_ok(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR o);
12907 export function CResult_PublicKeyNoneZ_is_ok(o: bigint): boolean {
12908 if(!isWasmInitialized) {
12909 throw new Error("initializeWasm() must be awaited first!");
12911 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_is_ok(o);
12912 return nativeResponseValue;
12914 // void CResult_PublicKeyNoneZ_free(struct LDKCResult_PublicKeyNoneZ _res);
12916 export function CResult_PublicKeyNoneZ_free(_res: bigint): void {
12917 if(!isWasmInitialized) {
12918 throw new Error("initializeWasm() must be awaited first!");
12920 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_free(_res);
12921 // debug statements here
12923 // uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg);
12925 export function CResult_PublicKeyNoneZ_clone_ptr(arg: bigint): bigint {
12926 if(!isWasmInitialized) {
12927 throw new Error("initializeWasm() must be awaited first!");
12929 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone_ptr(arg);
12930 return nativeResponseValue;
12932 // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_clone(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR orig);
12934 export function CResult_PublicKeyNoneZ_clone(orig: bigint): bigint {
12935 if(!isWasmInitialized) {
12936 throw new Error("initializeWasm() must be awaited first!");
12938 const nativeResponseValue = wasm.TS_CResult_PublicKeyNoneZ_clone(orig);
12939 return nativeResponseValue;
12941 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_some(struct LDKBigEndianScalar o);
12943 export function COption_BigEndianScalarZ_some(o: bigint): bigint {
12944 if(!isWasmInitialized) {
12945 throw new Error("initializeWasm() must be awaited first!");
12947 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_some(o);
12948 return nativeResponseValue;
12950 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_none(void);
12952 export function COption_BigEndianScalarZ_none(): bigint {
12953 if(!isWasmInitialized) {
12954 throw new Error("initializeWasm() must be awaited first!");
12956 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_none();
12957 return nativeResponseValue;
12959 // void COption_BigEndianScalarZ_free(struct LDKCOption_BigEndianScalarZ _res);
12961 export function COption_BigEndianScalarZ_free(_res: bigint): void {
12962 if(!isWasmInitialized) {
12963 throw new Error("initializeWasm() must be awaited first!");
12965 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_free(_res);
12966 // debug statements here
12968 // uint64_t COption_BigEndianScalarZ_clone_ptr(LDKCOption_BigEndianScalarZ *NONNULL_PTR arg);
12970 export function COption_BigEndianScalarZ_clone_ptr(arg: bigint): bigint {
12971 if(!isWasmInitialized) {
12972 throw new Error("initializeWasm() must be awaited first!");
12974 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_clone_ptr(arg);
12975 return nativeResponseValue;
12977 // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_clone(const struct LDKCOption_BigEndianScalarZ *NONNULL_PTR orig);
12979 export function COption_BigEndianScalarZ_clone(orig: bigint): bigint {
12980 if(!isWasmInitialized) {
12981 throw new Error("initializeWasm() must be awaited first!");
12983 const nativeResponseValue = wasm.TS_COption_BigEndianScalarZ_clone(orig);
12984 return nativeResponseValue;
12986 // void CVec_U5Z_free(struct LDKCVec_U5Z _res);
12988 export function CVec_U5Z_free(_res: number): void {
12989 if(!isWasmInitialized) {
12990 throw new Error("initializeWasm() must be awaited first!");
12992 const nativeResponseValue = wasm.TS_CVec_U5Z_free(_res);
12993 // debug statements here
12995 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
12997 export function CResult_RecoverableSignatureNoneZ_ok(o: number): bigint {
12998 if(!isWasmInitialized) {
12999 throw new Error("initializeWasm() must be awaited first!");
13001 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
13002 return nativeResponseValue;
13004 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
13006 export function CResult_RecoverableSignatureNoneZ_err(): bigint {
13007 if(!isWasmInitialized) {
13008 throw new Error("initializeWasm() must be awaited first!");
13010 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
13011 return nativeResponseValue;
13013 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
13015 export function CResult_RecoverableSignatureNoneZ_is_ok(o: bigint): boolean {
13016 if(!isWasmInitialized) {
13017 throw new Error("initializeWasm() must be awaited first!");
13019 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
13020 return nativeResponseValue;
13022 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
13024 export function CResult_RecoverableSignatureNoneZ_free(_res: bigint): void {
13025 if(!isWasmInitialized) {
13026 throw new Error("initializeWasm() must be awaited first!");
13028 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
13029 // debug statements here
13031 // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
13033 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: bigint): bigint {
13034 if(!isWasmInitialized) {
13035 throw new Error("initializeWasm() must be awaited first!");
13037 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
13038 return nativeResponseValue;
13040 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
13042 export function CResult_RecoverableSignatureNoneZ_clone(orig: bigint): bigint {
13043 if(!isWasmInitialized) {
13044 throw new Error("initializeWasm() must be awaited first!");
13046 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
13047 return nativeResponseValue;
13049 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_ok(struct LDKSchnorrSignature o);
13051 export function CResult_SchnorrSignatureNoneZ_ok(o: number): bigint {
13052 if(!isWasmInitialized) {
13053 throw new Error("initializeWasm() must be awaited first!");
13055 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_ok(o);
13056 return nativeResponseValue;
13058 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_err(void);
13060 export function CResult_SchnorrSignatureNoneZ_err(): bigint {
13061 if(!isWasmInitialized) {
13062 throw new Error("initializeWasm() must be awaited first!");
13064 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_err();
13065 return nativeResponseValue;
13067 // bool CResult_SchnorrSignatureNoneZ_is_ok(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR o);
13069 export function CResult_SchnorrSignatureNoneZ_is_ok(o: bigint): boolean {
13070 if(!isWasmInitialized) {
13071 throw new Error("initializeWasm() must be awaited first!");
13073 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_is_ok(o);
13074 return nativeResponseValue;
13076 // void CResult_SchnorrSignatureNoneZ_free(struct LDKCResult_SchnorrSignatureNoneZ _res);
13078 export function CResult_SchnorrSignatureNoneZ_free(_res: bigint): void {
13079 if(!isWasmInitialized) {
13080 throw new Error("initializeWasm() must be awaited first!");
13082 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_free(_res);
13083 // debug statements here
13085 // uint64_t CResult_SchnorrSignatureNoneZ_clone_ptr(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR arg);
13087 export function CResult_SchnorrSignatureNoneZ_clone_ptr(arg: bigint): bigint {
13088 if(!isWasmInitialized) {
13089 throw new Error("initializeWasm() must be awaited first!");
13091 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_clone_ptr(arg);
13092 return nativeResponseValue;
13094 // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_clone(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR orig);
13096 export function CResult_SchnorrSignatureNoneZ_clone(orig: bigint): bigint {
13097 if(!isWasmInitialized) {
13098 throw new Error("initializeWasm() must be awaited first!");
13100 const nativeResponseValue = wasm.TS_CResult_SchnorrSignatureNoneZ_clone(orig);
13101 return nativeResponseValue;
13103 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_ok(struct LDKECDSASignature o);
13105 export function CResult_ECDSASignatureNoneZ_ok(o: number): bigint {
13106 if(!isWasmInitialized) {
13107 throw new Error("initializeWasm() must be awaited first!");
13109 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_ok(o);
13110 return nativeResponseValue;
13112 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_err(void);
13114 export function CResult_ECDSASignatureNoneZ_err(): bigint {
13115 if(!isWasmInitialized) {
13116 throw new Error("initializeWasm() must be awaited first!");
13118 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_err();
13119 return nativeResponseValue;
13121 // bool CResult_ECDSASignatureNoneZ_is_ok(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR o);
13123 export function CResult_ECDSASignatureNoneZ_is_ok(o: bigint): boolean {
13124 if(!isWasmInitialized) {
13125 throw new Error("initializeWasm() must be awaited first!");
13127 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_is_ok(o);
13128 return nativeResponseValue;
13130 // void CResult_ECDSASignatureNoneZ_free(struct LDKCResult_ECDSASignatureNoneZ _res);
13132 export function CResult_ECDSASignatureNoneZ_free(_res: bigint): void {
13133 if(!isWasmInitialized) {
13134 throw new Error("initializeWasm() must be awaited first!");
13136 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_free(_res);
13137 // debug statements here
13139 // uint64_t CResult_ECDSASignatureNoneZ_clone_ptr(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR arg);
13141 export function CResult_ECDSASignatureNoneZ_clone_ptr(arg: bigint): bigint {
13142 if(!isWasmInitialized) {
13143 throw new Error("initializeWasm() must be awaited first!");
13145 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_clone_ptr(arg);
13146 return nativeResponseValue;
13148 // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_clone(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR orig);
13150 export function CResult_ECDSASignatureNoneZ_clone(orig: bigint): bigint {
13151 if(!isWasmInitialized) {
13152 throw new Error("initializeWasm() must be awaited first!");
13154 const nativeResponseValue = wasm.TS_CResult_ECDSASignatureNoneZ_clone(orig);
13155 return nativeResponseValue;
13157 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(struct LDKWriteableEcdsaChannelSigner o);
13159 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o: bigint): bigint {
13160 if(!isWasmInitialized) {
13161 throw new Error("initializeWasm() must be awaited first!");
13163 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o);
13164 return nativeResponseValue;
13166 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(struct LDKDecodeError e);
13168 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e: bigint): bigint {
13169 if(!isWasmInitialized) {
13170 throw new Error("initializeWasm() must be awaited first!");
13172 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e);
13173 return nativeResponseValue;
13175 // bool CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR o);
13177 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o: bigint): boolean {
13178 if(!isWasmInitialized) {
13179 throw new Error("initializeWasm() must be awaited first!");
13181 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o);
13182 return nativeResponseValue;
13184 // void CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ _res);
13186 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res: bigint): void {
13187 if(!isWasmInitialized) {
13188 throw new Error("initializeWasm() must be awaited first!");
13190 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res);
13191 // debug statements here
13193 // uint64_t CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR arg);
13195 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13196 if(!isWasmInitialized) {
13197 throw new Error("initializeWasm() must be awaited first!");
13199 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg);
13200 return nativeResponseValue;
13202 // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR orig);
13204 export function CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig: bigint): bigint {
13205 if(!isWasmInitialized) {
13206 throw new Error("initializeWasm() must be awaited first!");
13208 const nativeResponseValue = wasm.TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig);
13209 return nativeResponseValue;
13211 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_ok(struct LDKCVec_u8Z o);
13213 export function CResult_CVec_u8ZNoneZ_ok(o: number): bigint {
13214 if(!isWasmInitialized) {
13215 throw new Error("initializeWasm() must be awaited first!");
13217 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_ok(o);
13218 return nativeResponseValue;
13220 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_err(void);
13222 export function CResult_CVec_u8ZNoneZ_err(): bigint {
13223 if(!isWasmInitialized) {
13224 throw new Error("initializeWasm() must be awaited first!");
13226 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_err();
13227 return nativeResponseValue;
13229 // bool CResult_CVec_u8ZNoneZ_is_ok(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR o);
13231 export function CResult_CVec_u8ZNoneZ_is_ok(o: bigint): boolean {
13232 if(!isWasmInitialized) {
13233 throw new Error("initializeWasm() must be awaited first!");
13235 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_is_ok(o);
13236 return nativeResponseValue;
13238 // void CResult_CVec_u8ZNoneZ_free(struct LDKCResult_CVec_u8ZNoneZ _res);
13240 export function CResult_CVec_u8ZNoneZ_free(_res: bigint): void {
13241 if(!isWasmInitialized) {
13242 throw new Error("initializeWasm() must be awaited first!");
13244 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_free(_res);
13245 // debug statements here
13247 // uint64_t CResult_CVec_u8ZNoneZ_clone_ptr(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR arg);
13249 export function CResult_CVec_u8ZNoneZ_clone_ptr(arg: bigint): bigint {
13250 if(!isWasmInitialized) {
13251 throw new Error("initializeWasm() must be awaited first!");
13253 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_clone_ptr(arg);
13254 return nativeResponseValue;
13256 // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_clone(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR orig);
13258 export function CResult_CVec_u8ZNoneZ_clone(orig: bigint): bigint {
13259 if(!isWasmInitialized) {
13260 throw new Error("initializeWasm() must be awaited first!");
13262 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZNoneZ_clone(orig);
13263 return nativeResponseValue;
13265 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_ok(struct LDKShutdownScript o);
13267 export function CResult_ShutdownScriptNoneZ_ok(o: bigint): bigint {
13268 if(!isWasmInitialized) {
13269 throw new Error("initializeWasm() must be awaited first!");
13271 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_ok(o);
13272 return nativeResponseValue;
13274 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_err(void);
13276 export function CResult_ShutdownScriptNoneZ_err(): bigint {
13277 if(!isWasmInitialized) {
13278 throw new Error("initializeWasm() must be awaited first!");
13280 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_err();
13281 return nativeResponseValue;
13283 // bool CResult_ShutdownScriptNoneZ_is_ok(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR o);
13285 export function CResult_ShutdownScriptNoneZ_is_ok(o: bigint): boolean {
13286 if(!isWasmInitialized) {
13287 throw new Error("initializeWasm() must be awaited first!");
13289 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_is_ok(o);
13290 return nativeResponseValue;
13292 // void CResult_ShutdownScriptNoneZ_free(struct LDKCResult_ShutdownScriptNoneZ _res);
13294 export function CResult_ShutdownScriptNoneZ_free(_res: bigint): void {
13295 if(!isWasmInitialized) {
13296 throw new Error("initializeWasm() must be awaited first!");
13298 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_free(_res);
13299 // debug statements here
13301 // uint64_t CResult_ShutdownScriptNoneZ_clone_ptr(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR arg);
13303 export function CResult_ShutdownScriptNoneZ_clone_ptr(arg: bigint): bigint {
13304 if(!isWasmInitialized) {
13305 throw new Error("initializeWasm() must be awaited first!");
13307 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone_ptr(arg);
13308 return nativeResponseValue;
13310 // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_clone(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR orig);
13312 export function CResult_ShutdownScriptNoneZ_clone(orig: bigint): bigint {
13313 if(!isWasmInitialized) {
13314 throw new Error("initializeWasm() must be awaited first!");
13316 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptNoneZ_clone(orig);
13317 return nativeResponseValue;
13319 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
13321 export function COption_u16Z_some(o: number): bigint {
13322 if(!isWasmInitialized) {
13323 throw new Error("initializeWasm() must be awaited first!");
13325 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
13326 return nativeResponseValue;
13328 // struct LDKCOption_u16Z COption_u16Z_none(void);
13330 export function COption_u16Z_none(): bigint {
13331 if(!isWasmInitialized) {
13332 throw new Error("initializeWasm() must be awaited first!");
13334 const nativeResponseValue = wasm.TS_COption_u16Z_none();
13335 return nativeResponseValue;
13337 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
13339 export function COption_u16Z_free(_res: bigint): void {
13340 if(!isWasmInitialized) {
13341 throw new Error("initializeWasm() must be awaited first!");
13343 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
13344 // debug statements here
13346 // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
13348 export function COption_u16Z_clone_ptr(arg: bigint): bigint {
13349 if(!isWasmInitialized) {
13350 throw new Error("initializeWasm() must be awaited first!");
13352 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
13353 return nativeResponseValue;
13355 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
13357 export function COption_u16Z_clone(orig: bigint): bigint {
13358 if(!isWasmInitialized) {
13359 throw new Error("initializeWasm() must be awaited first!");
13361 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
13362 return nativeResponseValue;
13364 // struct LDKCOption_boolZ COption_boolZ_some(bool o);
13366 export function COption_boolZ_some(o: boolean): bigint {
13367 if(!isWasmInitialized) {
13368 throw new Error("initializeWasm() must be awaited first!");
13370 const nativeResponseValue = wasm.TS_COption_boolZ_some(o);
13371 return nativeResponseValue;
13373 // struct LDKCOption_boolZ COption_boolZ_none(void);
13375 export function COption_boolZ_none(): bigint {
13376 if(!isWasmInitialized) {
13377 throw new Error("initializeWasm() must be awaited first!");
13379 const nativeResponseValue = wasm.TS_COption_boolZ_none();
13380 return nativeResponseValue;
13382 // void COption_boolZ_free(struct LDKCOption_boolZ _res);
13384 export function COption_boolZ_free(_res: bigint): void {
13385 if(!isWasmInitialized) {
13386 throw new Error("initializeWasm() must be awaited first!");
13388 const nativeResponseValue = wasm.TS_COption_boolZ_free(_res);
13389 // debug statements here
13391 // uint64_t COption_boolZ_clone_ptr(LDKCOption_boolZ *NONNULL_PTR arg);
13393 export function COption_boolZ_clone_ptr(arg: bigint): bigint {
13394 if(!isWasmInitialized) {
13395 throw new Error("initializeWasm() must be awaited first!");
13397 const nativeResponseValue = wasm.TS_COption_boolZ_clone_ptr(arg);
13398 return nativeResponseValue;
13400 // struct LDKCOption_boolZ COption_boolZ_clone(const struct LDKCOption_boolZ *NONNULL_PTR orig);
13402 export function COption_boolZ_clone(orig: bigint): bigint {
13403 if(!isWasmInitialized) {
13404 throw new Error("initializeWasm() must be awaited first!");
13406 const nativeResponseValue = wasm.TS_COption_boolZ_clone(orig);
13407 return nativeResponseValue;
13409 // struct LDKCResult_WitnessNoneZ CResult_WitnessNoneZ_ok(struct LDKWitness o);
13411 export function CResult_WitnessNoneZ_ok(o: number): bigint {
13412 if(!isWasmInitialized) {
13413 throw new Error("initializeWasm() must be awaited first!");
13415 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_ok(o);
13416 return nativeResponseValue;
13418 // struct LDKCResult_WitnessNoneZ CResult_WitnessNoneZ_err(void);
13420 export function CResult_WitnessNoneZ_err(): bigint {
13421 if(!isWasmInitialized) {
13422 throw new Error("initializeWasm() must be awaited first!");
13424 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_err();
13425 return nativeResponseValue;
13427 // bool CResult_WitnessNoneZ_is_ok(const struct LDKCResult_WitnessNoneZ *NONNULL_PTR o);
13429 export function CResult_WitnessNoneZ_is_ok(o: bigint): boolean {
13430 if(!isWasmInitialized) {
13431 throw new Error("initializeWasm() must be awaited first!");
13433 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_is_ok(o);
13434 return nativeResponseValue;
13436 // void CResult_WitnessNoneZ_free(struct LDKCResult_WitnessNoneZ _res);
13438 export function CResult_WitnessNoneZ_free(_res: bigint): void {
13439 if(!isWasmInitialized) {
13440 throw new Error("initializeWasm() must be awaited first!");
13442 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_free(_res);
13443 // debug statements here
13445 // uint64_t CResult_WitnessNoneZ_clone_ptr(LDKCResult_WitnessNoneZ *NONNULL_PTR arg);
13447 export function CResult_WitnessNoneZ_clone_ptr(arg: bigint): bigint {
13448 if(!isWasmInitialized) {
13449 throw new Error("initializeWasm() must be awaited first!");
13451 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_clone_ptr(arg);
13452 return nativeResponseValue;
13454 // struct LDKCResult_WitnessNoneZ CResult_WitnessNoneZ_clone(const struct LDKCResult_WitnessNoneZ *NONNULL_PTR orig);
13456 export function CResult_WitnessNoneZ_clone(orig: bigint): bigint {
13457 if(!isWasmInitialized) {
13458 throw new Error("initializeWasm() must be awaited first!");
13460 const nativeResponseValue = wasm.TS_CResult_WitnessNoneZ_clone(orig);
13461 return nativeResponseValue;
13463 // void CVec_ECDSASignatureZ_free(struct LDKCVec_ECDSASignatureZ _res);
13465 export function CVec_ECDSASignatureZ_free(_res: number): void {
13466 if(!isWasmInitialized) {
13467 throw new Error("initializeWasm() must be awaited first!");
13469 const nativeResponseValue = wasm.TS_CVec_ECDSASignatureZ_free(_res);
13470 // debug statements here
13472 // uint64_t C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR arg);
13474 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(arg: bigint): bigint {
13475 if(!isWasmInitialized) {
13476 throw new Error("initializeWasm() must be awaited first!");
13478 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(arg);
13479 return nativeResponseValue;
13481 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(const struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR orig);
13483 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(orig: bigint): bigint {
13484 if(!isWasmInitialized) {
13485 throw new Error("initializeWasm() must be awaited first!");
13487 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(orig);
13488 return nativeResponseValue;
13490 // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(struct LDKECDSASignature a, struct LDKCVec_ECDSASignatureZ b);
13492 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(a: number, b: number): bigint {
13493 if(!isWasmInitialized) {
13494 throw new Error("initializeWasm() must be awaited first!");
13496 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(a, b);
13497 return nativeResponseValue;
13499 // void C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ _res);
13501 export function C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(_res: bigint): void {
13502 if(!isWasmInitialized) {
13503 throw new Error("initializeWasm() must be awaited first!");
13505 const nativeResponseValue = wasm.TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(_res);
13506 // debug statements here
13508 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ o);
13510 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(o: bigint): bigint {
13511 if(!isWasmInitialized) {
13512 throw new Error("initializeWasm() must be awaited first!");
13514 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(o);
13515 return nativeResponseValue;
13517 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err(void);
13519 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err(): bigint {
13520 if(!isWasmInitialized) {
13521 throw new Error("initializeWasm() must be awaited first!");
13523 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err();
13524 return nativeResponseValue;
13526 // bool CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR o);
13528 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(o: bigint): boolean {
13529 if(!isWasmInitialized) {
13530 throw new Error("initializeWasm() must be awaited first!");
13532 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(o);
13533 return nativeResponseValue;
13535 // void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ _res);
13537 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(_res: bigint): void {
13538 if(!isWasmInitialized) {
13539 throw new Error("initializeWasm() must be awaited first!");
13541 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(_res);
13542 // debug statements here
13544 // uint64_t CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR arg);
13546 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(arg: bigint): bigint {
13547 if(!isWasmInitialized) {
13548 throw new Error("initializeWasm() must be awaited first!");
13550 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(arg);
13551 return nativeResponseValue;
13553 // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR orig);
13555 export function CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(orig: bigint): bigint {
13556 if(!isWasmInitialized) {
13557 throw new Error("initializeWasm() must be awaited first!");
13559 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(orig);
13560 return nativeResponseValue;
13562 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
13564 export function CResult_InMemorySignerDecodeErrorZ_ok(o: bigint): bigint {
13565 if(!isWasmInitialized) {
13566 throw new Error("initializeWasm() must be awaited first!");
13568 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
13569 return nativeResponseValue;
13571 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
13573 export function CResult_InMemorySignerDecodeErrorZ_err(e: bigint): bigint {
13574 if(!isWasmInitialized) {
13575 throw new Error("initializeWasm() must be awaited first!");
13577 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
13578 return nativeResponseValue;
13580 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
13582 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: bigint): boolean {
13583 if(!isWasmInitialized) {
13584 throw new Error("initializeWasm() must be awaited first!");
13586 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
13587 return nativeResponseValue;
13589 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
13591 export function CResult_InMemorySignerDecodeErrorZ_free(_res: bigint): void {
13592 if(!isWasmInitialized) {
13593 throw new Error("initializeWasm() must be awaited first!");
13595 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
13596 // debug statements here
13598 // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
13600 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13601 if(!isWasmInitialized) {
13602 throw new Error("initializeWasm() must be awaited first!");
13604 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
13605 return nativeResponseValue;
13607 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
13609 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: bigint): bigint {
13610 if(!isWasmInitialized) {
13611 throw new Error("initializeWasm() must be awaited first!");
13613 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
13614 return nativeResponseValue;
13616 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
13618 export function CResult_TransactionNoneZ_ok(o: number): bigint {
13619 if(!isWasmInitialized) {
13620 throw new Error("initializeWasm() must be awaited first!");
13622 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
13623 return nativeResponseValue;
13625 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
13627 export function CResult_TransactionNoneZ_err(): bigint {
13628 if(!isWasmInitialized) {
13629 throw new Error("initializeWasm() must be awaited first!");
13631 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
13632 return nativeResponseValue;
13634 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
13636 export function CResult_TransactionNoneZ_is_ok(o: bigint): boolean {
13637 if(!isWasmInitialized) {
13638 throw new Error("initializeWasm() must be awaited first!");
13640 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
13641 return nativeResponseValue;
13643 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
13645 export function CResult_TransactionNoneZ_free(_res: bigint): void {
13646 if(!isWasmInitialized) {
13647 throw new Error("initializeWasm() must be awaited first!");
13649 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
13650 // debug statements here
13652 // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
13654 export function CResult_TransactionNoneZ_clone_ptr(arg: bigint): bigint {
13655 if(!isWasmInitialized) {
13656 throw new Error("initializeWasm() must be awaited first!");
13658 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
13659 return nativeResponseValue;
13661 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
13663 export function CResult_TransactionNoneZ_clone(orig: bigint): bigint {
13664 if(!isWasmInitialized) {
13665 throw new Error("initializeWasm() must be awaited first!");
13667 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
13668 return nativeResponseValue;
13670 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
13672 export function CVec_ChannelDetailsZ_free(_res: number): void {
13673 if(!isWasmInitialized) {
13674 throw new Error("initializeWasm() must be awaited first!");
13676 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
13677 // debug statements here
13679 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
13681 export function CResult_RouteLightningErrorZ_ok(o: bigint): bigint {
13682 if(!isWasmInitialized) {
13683 throw new Error("initializeWasm() must be awaited first!");
13685 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
13686 return nativeResponseValue;
13688 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
13690 export function CResult_RouteLightningErrorZ_err(e: bigint): bigint {
13691 if(!isWasmInitialized) {
13692 throw new Error("initializeWasm() must be awaited first!");
13694 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
13695 return nativeResponseValue;
13697 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
13699 export function CResult_RouteLightningErrorZ_is_ok(o: bigint): boolean {
13700 if(!isWasmInitialized) {
13701 throw new Error("initializeWasm() must be awaited first!");
13703 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
13704 return nativeResponseValue;
13706 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
13708 export function CResult_RouteLightningErrorZ_free(_res: bigint): void {
13709 if(!isWasmInitialized) {
13710 throw new Error("initializeWasm() must be awaited first!");
13712 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
13713 // debug statements here
13715 // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
13717 export function CResult_RouteLightningErrorZ_clone_ptr(arg: bigint): bigint {
13718 if(!isWasmInitialized) {
13719 throw new Error("initializeWasm() must be awaited first!");
13721 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
13722 return nativeResponseValue;
13724 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
13726 export function CResult_RouteLightningErrorZ_clone(orig: bigint): bigint {
13727 if(!isWasmInitialized) {
13728 throw new Error("initializeWasm() must be awaited first!");
13730 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
13731 return nativeResponseValue;
13733 // uint64_t C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR arg);
13735 export function C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg: bigint): bigint {
13736 if(!isWasmInitialized) {
13737 throw new Error("initializeWasm() must be awaited first!");
13739 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg);
13740 return nativeResponseValue;
13742 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_clone(const struct LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR orig);
13744 export function C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig: bigint): bigint {
13745 if(!isWasmInitialized) {
13746 throw new Error("initializeWasm() must be awaited first!");
13748 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig);
13749 return nativeResponseValue;
13751 // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_new(struct LDKBlindedPayInfo a, struct LDKBlindedPath b);
13753 export function C2Tuple_BlindedPayInfoBlindedPathZ_new(a: bigint, b: bigint): bigint {
13754 if(!isWasmInitialized) {
13755 throw new Error("initializeWasm() must be awaited first!");
13757 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_new(a, b);
13758 return nativeResponseValue;
13760 // void C2Tuple_BlindedPayInfoBlindedPathZ_free(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ _res);
13762 export function C2Tuple_BlindedPayInfoBlindedPathZ_free(_res: bigint): void {
13763 if(!isWasmInitialized) {
13764 throw new Error("initializeWasm() must be awaited first!");
13766 const nativeResponseValue = wasm.TS_C2Tuple_BlindedPayInfoBlindedPathZ_free(_res);
13767 // debug statements here
13769 // void CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ _res);
13771 export function CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res: number): void {
13772 if(!isWasmInitialized) {
13773 throw new Error("initializeWasm() must be awaited first!");
13775 const nativeResponseValue = wasm.TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res);
13776 // debug statements here
13778 // struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_ok(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ o);
13780 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_ok(o: number): bigint {
13781 if(!isWasmInitialized) {
13782 throw new Error("initializeWasm() must be awaited first!");
13784 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_ok(o);
13785 return nativeResponseValue;
13787 // struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_err(void);
13789 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_err(): bigint {
13790 if(!isWasmInitialized) {
13791 throw new Error("initializeWasm() must be awaited first!");
13793 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_err();
13794 return nativeResponseValue;
13796 // bool CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_is_ok(const struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR o);
13798 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_is_ok(o: bigint): boolean {
13799 if(!isWasmInitialized) {
13800 throw new Error("initializeWasm() must be awaited first!");
13802 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_is_ok(o);
13803 return nativeResponseValue;
13805 // void CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ _res);
13807 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(_res: bigint): void {
13808 if(!isWasmInitialized) {
13809 throw new Error("initializeWasm() must be awaited first!");
13811 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(_res);
13812 // debug statements here
13814 // uint64_t CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone_ptr(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR arg);
13816 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone_ptr(arg: bigint): bigint {
13817 if(!isWasmInitialized) {
13818 throw new Error("initializeWasm() must be awaited first!");
13820 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone_ptr(arg);
13821 return nativeResponseValue;
13823 // struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone(const struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR orig);
13825 export function CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone(orig: bigint): bigint {
13826 if(!isWasmInitialized) {
13827 throw new Error("initializeWasm() must be awaited first!");
13829 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone(orig);
13830 return nativeResponseValue;
13832 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
13834 export function CVec_PublicKeyZ_free(_res: number): void {
13835 if(!isWasmInitialized) {
13836 throw new Error("initializeWasm() must be awaited first!");
13838 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
13839 // debug statements here
13841 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_ok(struct LDKOnionMessagePath o);
13843 export function CResult_OnionMessagePathNoneZ_ok(o: bigint): bigint {
13844 if(!isWasmInitialized) {
13845 throw new Error("initializeWasm() must be awaited first!");
13847 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_ok(o);
13848 return nativeResponseValue;
13850 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_err(void);
13852 export function CResult_OnionMessagePathNoneZ_err(): bigint {
13853 if(!isWasmInitialized) {
13854 throw new Error("initializeWasm() must be awaited first!");
13856 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_err();
13857 return nativeResponseValue;
13859 // bool CResult_OnionMessagePathNoneZ_is_ok(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR o);
13861 export function CResult_OnionMessagePathNoneZ_is_ok(o: bigint): boolean {
13862 if(!isWasmInitialized) {
13863 throw new Error("initializeWasm() must be awaited first!");
13865 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_is_ok(o);
13866 return nativeResponseValue;
13868 // void CResult_OnionMessagePathNoneZ_free(struct LDKCResult_OnionMessagePathNoneZ _res);
13870 export function CResult_OnionMessagePathNoneZ_free(_res: bigint): void {
13871 if(!isWasmInitialized) {
13872 throw new Error("initializeWasm() must be awaited first!");
13874 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_free(_res);
13875 // debug statements here
13877 // uint64_t CResult_OnionMessagePathNoneZ_clone_ptr(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR arg);
13879 export function CResult_OnionMessagePathNoneZ_clone_ptr(arg: bigint): bigint {
13880 if(!isWasmInitialized) {
13881 throw new Error("initializeWasm() must be awaited first!");
13883 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_clone_ptr(arg);
13884 return nativeResponseValue;
13886 // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_clone(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR orig);
13888 export function CResult_OnionMessagePathNoneZ_clone(orig: bigint): bigint {
13889 if(!isWasmInitialized) {
13890 throw new Error("initializeWasm() must be awaited first!");
13892 const nativeResponseValue = wasm.TS_CResult_OnionMessagePathNoneZ_clone(orig);
13893 return nativeResponseValue;
13895 // struct LDKCResult_CVec_BlindedPathZNoneZ CResult_CVec_BlindedPathZNoneZ_ok(struct LDKCVec_BlindedPathZ o);
13897 export function CResult_CVec_BlindedPathZNoneZ_ok(o: number): bigint {
13898 if(!isWasmInitialized) {
13899 throw new Error("initializeWasm() must be awaited first!");
13901 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_ok(o);
13902 return nativeResponseValue;
13904 // struct LDKCResult_CVec_BlindedPathZNoneZ CResult_CVec_BlindedPathZNoneZ_err(void);
13906 export function CResult_CVec_BlindedPathZNoneZ_err(): bigint {
13907 if(!isWasmInitialized) {
13908 throw new Error("initializeWasm() must be awaited first!");
13910 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_err();
13911 return nativeResponseValue;
13913 // bool CResult_CVec_BlindedPathZNoneZ_is_ok(const struct LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR o);
13915 export function CResult_CVec_BlindedPathZNoneZ_is_ok(o: bigint): boolean {
13916 if(!isWasmInitialized) {
13917 throw new Error("initializeWasm() must be awaited first!");
13919 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_is_ok(o);
13920 return nativeResponseValue;
13922 // void CResult_CVec_BlindedPathZNoneZ_free(struct LDKCResult_CVec_BlindedPathZNoneZ _res);
13924 export function CResult_CVec_BlindedPathZNoneZ_free(_res: bigint): void {
13925 if(!isWasmInitialized) {
13926 throw new Error("initializeWasm() must be awaited first!");
13928 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_free(_res);
13929 // debug statements here
13931 // uint64_t CResult_CVec_BlindedPathZNoneZ_clone_ptr(LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR arg);
13933 export function CResult_CVec_BlindedPathZNoneZ_clone_ptr(arg: bigint): bigint {
13934 if(!isWasmInitialized) {
13935 throw new Error("initializeWasm() must be awaited first!");
13937 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_clone_ptr(arg);
13938 return nativeResponseValue;
13940 // struct LDKCResult_CVec_BlindedPathZNoneZ CResult_CVec_BlindedPathZNoneZ_clone(const struct LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR orig);
13942 export function CResult_CVec_BlindedPathZNoneZ_clone(orig: bigint): bigint {
13943 if(!isWasmInitialized) {
13944 throw new Error("initializeWasm() must be awaited first!");
13946 const nativeResponseValue = wasm.TS_CResult_CVec_BlindedPathZNoneZ_clone(orig);
13947 return nativeResponseValue;
13949 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
13951 export function CResult_InFlightHtlcsDecodeErrorZ_ok(o: bigint): bigint {
13952 if(!isWasmInitialized) {
13953 throw new Error("initializeWasm() must be awaited first!");
13955 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_ok(o);
13956 return nativeResponseValue;
13958 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_err(struct LDKDecodeError e);
13960 export function CResult_InFlightHtlcsDecodeErrorZ_err(e: bigint): bigint {
13961 if(!isWasmInitialized) {
13962 throw new Error("initializeWasm() must be awaited first!");
13964 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_err(e);
13965 return nativeResponseValue;
13967 // bool CResult_InFlightHtlcsDecodeErrorZ_is_ok(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR o);
13969 export function CResult_InFlightHtlcsDecodeErrorZ_is_ok(o: bigint): boolean {
13970 if(!isWasmInitialized) {
13971 throw new Error("initializeWasm() must be awaited first!");
13973 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(o);
13974 return nativeResponseValue;
13976 // void CResult_InFlightHtlcsDecodeErrorZ_free(struct LDKCResult_InFlightHtlcsDecodeErrorZ _res);
13978 export function CResult_InFlightHtlcsDecodeErrorZ_free(_res: bigint): void {
13979 if(!isWasmInitialized) {
13980 throw new Error("initializeWasm() must be awaited first!");
13982 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_free(_res);
13983 // debug statements here
13985 // uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg);
13987 export function CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
13988 if(!isWasmInitialized) {
13989 throw new Error("initializeWasm() must be awaited first!");
13991 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg);
13992 return nativeResponseValue;
13994 // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_clone(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR orig);
13996 export function CResult_InFlightHtlcsDecodeErrorZ_clone(orig: bigint): bigint {
13997 if(!isWasmInitialized) {
13998 throw new Error("initializeWasm() must be awaited first!");
14000 const nativeResponseValue = wasm.TS_CResult_InFlightHtlcsDecodeErrorZ_clone(orig);
14001 return nativeResponseValue;
14003 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
14005 export function CResult_RouteHopDecodeErrorZ_ok(o: bigint): bigint {
14006 if(!isWasmInitialized) {
14007 throw new Error("initializeWasm() must be awaited first!");
14009 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
14010 return nativeResponseValue;
14012 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
14014 export function CResult_RouteHopDecodeErrorZ_err(e: bigint): bigint {
14015 if(!isWasmInitialized) {
14016 throw new Error("initializeWasm() must be awaited first!");
14018 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
14019 return nativeResponseValue;
14021 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
14023 export function CResult_RouteHopDecodeErrorZ_is_ok(o: bigint): boolean {
14024 if(!isWasmInitialized) {
14025 throw new Error("initializeWasm() must be awaited first!");
14027 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
14028 return nativeResponseValue;
14030 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
14032 export function CResult_RouteHopDecodeErrorZ_free(_res: bigint): void {
14033 if(!isWasmInitialized) {
14034 throw new Error("initializeWasm() must be awaited first!");
14036 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
14037 // debug statements here
14039 // uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
14041 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14042 if(!isWasmInitialized) {
14043 throw new Error("initializeWasm() must be awaited first!");
14045 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
14046 return nativeResponseValue;
14048 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
14050 export function CResult_RouteHopDecodeErrorZ_clone(orig: bigint): bigint {
14051 if(!isWasmInitialized) {
14052 throw new Error("initializeWasm() must be awaited first!");
14054 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
14055 return nativeResponseValue;
14057 // void CVec_BlindedHopZ_free(struct LDKCVec_BlindedHopZ _res);
14059 export function CVec_BlindedHopZ_free(_res: number): void {
14060 if(!isWasmInitialized) {
14061 throw new Error("initializeWasm() must be awaited first!");
14063 const nativeResponseValue = wasm.TS_CVec_BlindedHopZ_free(_res);
14064 // debug statements here
14066 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_ok(struct LDKBlindedTail o);
14068 export function CResult_BlindedTailDecodeErrorZ_ok(o: bigint): bigint {
14069 if(!isWasmInitialized) {
14070 throw new Error("initializeWasm() must be awaited first!");
14072 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_ok(o);
14073 return nativeResponseValue;
14075 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_err(struct LDKDecodeError e);
14077 export function CResult_BlindedTailDecodeErrorZ_err(e: bigint): bigint {
14078 if(!isWasmInitialized) {
14079 throw new Error("initializeWasm() must be awaited first!");
14081 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_err(e);
14082 return nativeResponseValue;
14084 // bool CResult_BlindedTailDecodeErrorZ_is_ok(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR o);
14086 export function CResult_BlindedTailDecodeErrorZ_is_ok(o: bigint): boolean {
14087 if(!isWasmInitialized) {
14088 throw new Error("initializeWasm() must be awaited first!");
14090 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_is_ok(o);
14091 return nativeResponseValue;
14093 // void CResult_BlindedTailDecodeErrorZ_free(struct LDKCResult_BlindedTailDecodeErrorZ _res);
14095 export function CResult_BlindedTailDecodeErrorZ_free(_res: bigint): void {
14096 if(!isWasmInitialized) {
14097 throw new Error("initializeWasm() must be awaited first!");
14099 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_free(_res);
14100 // debug statements here
14102 // uint64_t CResult_BlindedTailDecodeErrorZ_clone_ptr(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR arg);
14104 export function CResult_BlindedTailDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14105 if(!isWasmInitialized) {
14106 throw new Error("initializeWasm() must be awaited first!");
14108 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone_ptr(arg);
14109 return nativeResponseValue;
14111 // struct LDKCResult_BlindedTailDecodeErrorZ CResult_BlindedTailDecodeErrorZ_clone(const struct LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR orig);
14113 export function CResult_BlindedTailDecodeErrorZ_clone(orig: bigint): bigint {
14114 if(!isWasmInitialized) {
14115 throw new Error("initializeWasm() must be awaited first!");
14117 const nativeResponseValue = wasm.TS_CResult_BlindedTailDecodeErrorZ_clone(orig);
14118 return nativeResponseValue;
14120 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
14122 export function CVec_RouteHopZ_free(_res: number): void {
14123 if(!isWasmInitialized) {
14124 throw new Error("initializeWasm() must be awaited first!");
14126 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
14127 // debug statements here
14129 // void CVec_PathZ_free(struct LDKCVec_PathZ _res);
14131 export function CVec_PathZ_free(_res: number): void {
14132 if(!isWasmInitialized) {
14133 throw new Error("initializeWasm() must be awaited first!");
14135 const nativeResponseValue = wasm.TS_CVec_PathZ_free(_res);
14136 // debug statements here
14138 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
14140 export function CResult_RouteDecodeErrorZ_ok(o: bigint): bigint {
14141 if(!isWasmInitialized) {
14142 throw new Error("initializeWasm() must be awaited first!");
14144 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
14145 return nativeResponseValue;
14147 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
14149 export function CResult_RouteDecodeErrorZ_err(e: bigint): bigint {
14150 if(!isWasmInitialized) {
14151 throw new Error("initializeWasm() must be awaited first!");
14153 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
14154 return nativeResponseValue;
14156 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
14158 export function CResult_RouteDecodeErrorZ_is_ok(o: bigint): boolean {
14159 if(!isWasmInitialized) {
14160 throw new Error("initializeWasm() must be awaited first!");
14162 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
14163 return nativeResponseValue;
14165 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
14167 export function CResult_RouteDecodeErrorZ_free(_res: bigint): void {
14168 if(!isWasmInitialized) {
14169 throw new Error("initializeWasm() must be awaited first!");
14171 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
14172 // debug statements here
14174 // uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
14176 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14177 if(!isWasmInitialized) {
14178 throw new Error("initializeWasm() must be awaited first!");
14180 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
14181 return nativeResponseValue;
14183 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
14185 export function CResult_RouteDecodeErrorZ_clone(orig: bigint): bigint {
14186 if(!isWasmInitialized) {
14187 throw new Error("initializeWasm() must be awaited first!");
14189 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
14190 return nativeResponseValue;
14192 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
14194 export function CResult_RouteParametersDecodeErrorZ_ok(o: bigint): bigint {
14195 if(!isWasmInitialized) {
14196 throw new Error("initializeWasm() must be awaited first!");
14198 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
14199 return nativeResponseValue;
14201 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
14203 export function CResult_RouteParametersDecodeErrorZ_err(e: bigint): bigint {
14204 if(!isWasmInitialized) {
14205 throw new Error("initializeWasm() must be awaited first!");
14207 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
14208 return nativeResponseValue;
14210 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
14212 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: bigint): boolean {
14213 if(!isWasmInitialized) {
14214 throw new Error("initializeWasm() must be awaited first!");
14216 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
14217 return nativeResponseValue;
14219 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
14221 export function CResult_RouteParametersDecodeErrorZ_free(_res: bigint): void {
14222 if(!isWasmInitialized) {
14223 throw new Error("initializeWasm() must be awaited first!");
14225 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
14226 // debug statements here
14228 // uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
14230 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14231 if(!isWasmInitialized) {
14232 throw new Error("initializeWasm() must be awaited first!");
14234 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
14235 return nativeResponseValue;
14237 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
14239 export function CResult_RouteParametersDecodeErrorZ_clone(orig: bigint): bigint {
14240 if(!isWasmInitialized) {
14241 throw new Error("initializeWasm() must be awaited first!");
14243 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
14244 return nativeResponseValue;
14246 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
14248 export function CVec_u64Z_free(_res: number): void {
14249 if(!isWasmInitialized) {
14250 throw new Error("initializeWasm() must be awaited first!");
14252 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
14253 // debug statements here
14255 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
14257 export function CResult_PaymentParametersDecodeErrorZ_ok(o: bigint): bigint {
14258 if(!isWasmInitialized) {
14259 throw new Error("initializeWasm() must be awaited first!");
14261 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
14262 return nativeResponseValue;
14264 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
14266 export function CResult_PaymentParametersDecodeErrorZ_err(e: bigint): bigint {
14267 if(!isWasmInitialized) {
14268 throw new Error("initializeWasm() must be awaited first!");
14270 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
14271 return nativeResponseValue;
14273 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
14275 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: bigint): boolean {
14276 if(!isWasmInitialized) {
14277 throw new Error("initializeWasm() must be awaited first!");
14279 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
14280 return nativeResponseValue;
14282 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
14284 export function CResult_PaymentParametersDecodeErrorZ_free(_res: bigint): void {
14285 if(!isWasmInitialized) {
14286 throw new Error("initializeWasm() must be awaited first!");
14288 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
14289 // debug statements here
14291 // uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
14293 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14294 if(!isWasmInitialized) {
14295 throw new Error("initializeWasm() must be awaited first!");
14297 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
14298 return nativeResponseValue;
14300 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
14302 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: bigint): bigint {
14303 if(!isWasmInitialized) {
14304 throw new Error("initializeWasm() must be awaited first!");
14306 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
14307 return nativeResponseValue;
14309 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
14311 export function CVec_RouteHintZ_free(_res: number): void {
14312 if(!isWasmInitialized) {
14313 throw new Error("initializeWasm() must be awaited first!");
14315 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
14316 // debug statements here
14318 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
14320 export function CVec_RouteHintHopZ_free(_res: number): void {
14321 if(!isWasmInitialized) {
14322 throw new Error("initializeWasm() must be awaited first!");
14324 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
14325 // debug statements here
14327 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
14329 export function CResult_RouteHintDecodeErrorZ_ok(o: bigint): bigint {
14330 if(!isWasmInitialized) {
14331 throw new Error("initializeWasm() must be awaited first!");
14333 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
14334 return nativeResponseValue;
14336 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
14338 export function CResult_RouteHintDecodeErrorZ_err(e: bigint): bigint {
14339 if(!isWasmInitialized) {
14340 throw new Error("initializeWasm() must be awaited first!");
14342 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
14343 return nativeResponseValue;
14345 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
14347 export function CResult_RouteHintDecodeErrorZ_is_ok(o: bigint): boolean {
14348 if(!isWasmInitialized) {
14349 throw new Error("initializeWasm() must be awaited first!");
14351 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
14352 return nativeResponseValue;
14354 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
14356 export function CResult_RouteHintDecodeErrorZ_free(_res: bigint): void {
14357 if(!isWasmInitialized) {
14358 throw new Error("initializeWasm() must be awaited first!");
14360 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
14361 // debug statements here
14363 // uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
14365 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14366 if(!isWasmInitialized) {
14367 throw new Error("initializeWasm() must be awaited first!");
14369 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
14370 return nativeResponseValue;
14372 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
14374 export function CResult_RouteHintDecodeErrorZ_clone(orig: bigint): bigint {
14375 if(!isWasmInitialized) {
14376 throw new Error("initializeWasm() must be awaited first!");
14378 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
14379 return nativeResponseValue;
14381 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
14383 export function CResult_RouteHintHopDecodeErrorZ_ok(o: bigint): bigint {
14384 if(!isWasmInitialized) {
14385 throw new Error("initializeWasm() must be awaited first!");
14387 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
14388 return nativeResponseValue;
14390 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
14392 export function CResult_RouteHintHopDecodeErrorZ_err(e: bigint): bigint {
14393 if(!isWasmInitialized) {
14394 throw new Error("initializeWasm() must be awaited first!");
14396 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
14397 return nativeResponseValue;
14399 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
14401 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: bigint): boolean {
14402 if(!isWasmInitialized) {
14403 throw new Error("initializeWasm() must be awaited first!");
14405 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
14406 return nativeResponseValue;
14408 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
14410 export function CResult_RouteHintHopDecodeErrorZ_free(_res: bigint): void {
14411 if(!isWasmInitialized) {
14412 throw new Error("initializeWasm() must be awaited first!");
14414 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
14415 // debug statements here
14417 // uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
14419 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14420 if(!isWasmInitialized) {
14421 throw new Error("initializeWasm() must be awaited first!");
14423 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
14424 return nativeResponseValue;
14426 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
14428 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: bigint): bigint {
14429 if(!isWasmInitialized) {
14430 throw new Error("initializeWasm() must be awaited first!");
14432 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
14433 return nativeResponseValue;
14435 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
14437 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: bigint): bigint {
14438 if(!isWasmInitialized) {
14439 throw new Error("initializeWasm() must be awaited first!");
14441 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
14442 return nativeResponseValue;
14444 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
14446 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: bigint): bigint {
14447 if(!isWasmInitialized) {
14448 throw new Error("initializeWasm() must be awaited first!");
14450 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
14451 return nativeResponseValue;
14453 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
14455 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: bigint): boolean {
14456 if(!isWasmInitialized) {
14457 throw new Error("initializeWasm() must be awaited first!");
14459 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
14460 return nativeResponseValue;
14462 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
14464 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: bigint): void {
14465 if(!isWasmInitialized) {
14466 throw new Error("initializeWasm() must be awaited first!");
14468 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
14469 // debug statements here
14471 // uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
14473 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14474 if(!isWasmInitialized) {
14475 throw new Error("initializeWasm() must be awaited first!");
14477 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
14478 return nativeResponseValue;
14480 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
14482 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: bigint): bigint {
14483 if(!isWasmInitialized) {
14484 throw new Error("initializeWasm() must be awaited first!");
14486 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
14487 return nativeResponseValue;
14489 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
14491 export function CVec_NodeIdZ_free(_res: number): void {
14492 if(!isWasmInitialized) {
14493 throw new Error("initializeWasm() must be awaited first!");
14495 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
14496 // debug statements here
14498 // uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
14500 export function C2Tuple_u64u64Z_clone_ptr(arg: bigint): bigint {
14501 if(!isWasmInitialized) {
14502 throw new Error("initializeWasm() must be awaited first!");
14504 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
14505 return nativeResponseValue;
14507 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
14509 export function C2Tuple_u64u64Z_clone(orig: bigint): bigint {
14510 if(!isWasmInitialized) {
14511 throw new Error("initializeWasm() must be awaited first!");
14513 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
14514 return nativeResponseValue;
14516 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
14518 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): bigint {
14519 if(!isWasmInitialized) {
14520 throw new Error("initializeWasm() must be awaited first!");
14522 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
14523 return nativeResponseValue;
14525 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
14527 export function C2Tuple_u64u64Z_free(_res: bigint): void {
14528 if(!isWasmInitialized) {
14529 throw new Error("initializeWasm() must be awaited first!");
14531 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
14532 // debug statements here
14534 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
14536 export function COption_C2Tuple_u64u64ZZ_some(o: bigint): bigint {
14537 if(!isWasmInitialized) {
14538 throw new Error("initializeWasm() must be awaited first!");
14540 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
14541 return nativeResponseValue;
14543 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
14545 export function COption_C2Tuple_u64u64ZZ_none(): bigint {
14546 if(!isWasmInitialized) {
14547 throw new Error("initializeWasm() must be awaited first!");
14549 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
14550 return nativeResponseValue;
14552 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
14554 export function COption_C2Tuple_u64u64ZZ_free(_res: bigint): void {
14555 if(!isWasmInitialized) {
14556 throw new Error("initializeWasm() must be awaited first!");
14558 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
14559 // debug statements here
14561 // uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
14563 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: bigint): bigint {
14564 if(!isWasmInitialized) {
14565 throw new Error("initializeWasm() must be awaited first!");
14567 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
14568 return nativeResponseValue;
14570 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
14572 export function COption_C2Tuple_u64u64ZZ_clone(orig: bigint): bigint {
14573 if(!isWasmInitialized) {
14574 throw new Error("initializeWasm() must be awaited first!");
14576 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
14577 return nativeResponseValue;
14579 // struct LDKC2Tuple_Z C2Tuple_Z_new(struct LDKThirtyTwoU16s a, struct LDKThirtyTwoU16s b);
14581 export function C2Tuple_Z_new(a: number, b: number): bigint {
14582 if(!isWasmInitialized) {
14583 throw new Error("initializeWasm() must be awaited first!");
14585 const nativeResponseValue = wasm.TS_C2Tuple_Z_new(a, b);
14586 return nativeResponseValue;
14588 // void C2Tuple_Z_free(struct LDKC2Tuple_Z _res);
14590 export function C2Tuple_Z_free(_res: bigint): void {
14591 if(!isWasmInitialized) {
14592 throw new Error("initializeWasm() must be awaited first!");
14594 const nativeResponseValue = wasm.TS_C2Tuple_Z_free(_res);
14595 // debug statements here
14597 // struct LDKC2Tuple__u1632_u1632Z C2Tuple__u1632_u1632Z_new(struct LDKThirtyTwoU16s a, struct LDKThirtyTwoU16s b);
14599 export function C2Tuple__u1632_u1632Z_new(a: number, b: number): bigint {
14600 if(!isWasmInitialized) {
14601 throw new Error("initializeWasm() must be awaited first!");
14603 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_new(a, b);
14604 return nativeResponseValue;
14606 // void C2Tuple__u1632_u1632Z_free(struct LDKC2Tuple__u1632_u1632Z _res);
14608 export function C2Tuple__u1632_u1632Z_free(_res: bigint): void {
14609 if(!isWasmInitialized) {
14610 throw new Error("initializeWasm() must be awaited first!");
14612 const nativeResponseValue = wasm.TS_C2Tuple__u1632_u1632Z_free(_res);
14613 // debug statements here
14615 // struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(struct LDKC2Tuple__u1632_u1632Z o);
14617 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(o: bigint): bigint {
14618 if(!isWasmInitialized) {
14619 throw new Error("initializeWasm() must be awaited first!");
14621 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(o);
14622 return nativeResponseValue;
14624 // struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none(void);
14626 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none(): bigint {
14627 if(!isWasmInitialized) {
14628 throw new Error("initializeWasm() must be awaited first!");
14630 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none();
14631 return nativeResponseValue;
14633 // void COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(struct LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ _res);
14635 export function COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(_res: bigint): void {
14636 if(!isWasmInitialized) {
14637 throw new Error("initializeWasm() must be awaited first!");
14639 const nativeResponseValue = wasm.TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(_res);
14640 // debug statements here
14642 // struct LDKCOption_f64Z COption_f64Z_some(double o);
14644 export function COption_f64Z_some(o: number): bigint {
14645 if(!isWasmInitialized) {
14646 throw new Error("initializeWasm() must be awaited first!");
14648 const nativeResponseValue = wasm.TS_COption_f64Z_some(o);
14649 return nativeResponseValue;
14651 // struct LDKCOption_f64Z COption_f64Z_none(void);
14653 export function COption_f64Z_none(): bigint {
14654 if(!isWasmInitialized) {
14655 throw new Error("initializeWasm() must be awaited first!");
14657 const nativeResponseValue = wasm.TS_COption_f64Z_none();
14658 return nativeResponseValue;
14660 // void COption_f64Z_free(struct LDKCOption_f64Z _res);
14662 export function COption_f64Z_free(_res: bigint): void {
14663 if(!isWasmInitialized) {
14664 throw new Error("initializeWasm() must be awaited first!");
14666 const nativeResponseValue = wasm.TS_COption_f64Z_free(_res);
14667 // debug statements here
14669 // uint64_t COption_f64Z_clone_ptr(LDKCOption_f64Z *NONNULL_PTR arg);
14671 export function COption_f64Z_clone_ptr(arg: bigint): bigint {
14672 if(!isWasmInitialized) {
14673 throw new Error("initializeWasm() must be awaited first!");
14675 const nativeResponseValue = wasm.TS_COption_f64Z_clone_ptr(arg);
14676 return nativeResponseValue;
14678 // struct LDKCOption_f64Z COption_f64Z_clone(const struct LDKCOption_f64Z *NONNULL_PTR orig);
14680 export function COption_f64Z_clone(orig: bigint): bigint {
14681 if(!isWasmInitialized) {
14682 throw new Error("initializeWasm() must be awaited first!");
14684 const nativeResponseValue = wasm.TS_COption_f64Z_clone(orig);
14685 return nativeResponseValue;
14687 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
14689 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: bigint): bigint {
14690 if(!isWasmInitialized) {
14691 throw new Error("initializeWasm() must be awaited first!");
14693 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
14694 return nativeResponseValue;
14696 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
14698 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: bigint): bigint {
14699 if(!isWasmInitialized) {
14700 throw new Error("initializeWasm() must be awaited first!");
14702 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
14703 return nativeResponseValue;
14705 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
14707 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: bigint): boolean {
14708 if(!isWasmInitialized) {
14709 throw new Error("initializeWasm() must be awaited first!");
14711 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
14712 return nativeResponseValue;
14714 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
14716 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: bigint): void {
14717 if(!isWasmInitialized) {
14718 throw new Error("initializeWasm() must be awaited first!");
14720 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
14721 // debug statements here
14723 // uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
14725 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: bigint): bigint {
14726 if(!isWasmInitialized) {
14727 throw new Error("initializeWasm() must be awaited first!");
14729 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
14730 return nativeResponseValue;
14732 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
14734 export function C2Tuple_usizeTransactionZ_clone(orig: bigint): bigint {
14735 if(!isWasmInitialized) {
14736 throw new Error("initializeWasm() must be awaited first!");
14738 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
14739 return nativeResponseValue;
14741 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
14743 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): bigint {
14744 if(!isWasmInitialized) {
14745 throw new Error("initializeWasm() must be awaited first!");
14747 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
14748 return nativeResponseValue;
14750 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
14752 export function C2Tuple_usizeTransactionZ_free(_res: bigint): void {
14753 if(!isWasmInitialized) {
14754 throw new Error("initializeWasm() must be awaited first!");
14756 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
14757 // debug statements here
14759 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
14761 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
14762 if(!isWasmInitialized) {
14763 throw new Error("initializeWasm() must be awaited first!");
14765 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
14766 // debug statements here
14768 // uint64_t C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone_ptr(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ *NONNULL_PTR arg);
14770 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone_ptr(arg: bigint): bigint {
14771 if(!isWasmInitialized) {
14772 throw new Error("initializeWasm() must be awaited first!");
14774 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone_ptr(arg);
14775 return nativeResponseValue;
14777 // struct LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone(const struct LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ *NONNULL_PTR orig);
14779 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone(orig: bigint): bigint {
14780 if(!isWasmInitialized) {
14781 throw new Error("initializeWasm() must be awaited first!");
14783 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_clone(orig);
14784 return nativeResponseValue;
14786 // struct LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_new(struct LDKThirtyTwoBytes a, uint32_t b, struct LDKCOption_ThirtyTwoBytesZ c);
14788 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_new(a: number, b: number, c: bigint): bigint {
14789 if(!isWasmInitialized) {
14790 throw new Error("initializeWasm() must be awaited first!");
14792 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_new(a, b, c);
14793 return nativeResponseValue;
14795 // void C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(struct LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ _res);
14797 export function C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(_res: bigint): void {
14798 if(!isWasmInitialized) {
14799 throw new Error("initializeWasm() must be awaited first!");
14801 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(_res);
14802 // debug statements here
14804 // void CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(struct LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ _res);
14806 export function CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(_res: number): void {
14807 if(!isWasmInitialized) {
14808 throw new Error("initializeWasm() must be awaited first!");
14810 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(_res);
14811 // debug statements here
14813 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_ok(enum LDKChannelMonitorUpdateStatus o);
14815 export function CResult_ChannelMonitorUpdateStatusNoneZ_ok(o: ChannelMonitorUpdateStatus): bigint {
14816 if(!isWasmInitialized) {
14817 throw new Error("initializeWasm() must be awaited first!");
14819 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_ok(o);
14820 return nativeResponseValue;
14822 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_err(void);
14824 export function CResult_ChannelMonitorUpdateStatusNoneZ_err(): bigint {
14825 if(!isWasmInitialized) {
14826 throw new Error("initializeWasm() must be awaited first!");
14828 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_err();
14829 return nativeResponseValue;
14831 // bool CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR o);
14833 export function CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(o: bigint): boolean {
14834 if(!isWasmInitialized) {
14835 throw new Error("initializeWasm() must be awaited first!");
14837 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(o);
14838 return nativeResponseValue;
14840 // void CResult_ChannelMonitorUpdateStatusNoneZ_free(struct LDKCResult_ChannelMonitorUpdateStatusNoneZ _res);
14842 export function CResult_ChannelMonitorUpdateStatusNoneZ_free(_res: bigint): void {
14843 if(!isWasmInitialized) {
14844 throw new Error("initializeWasm() must be awaited first!");
14846 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_free(_res);
14847 // debug statements here
14849 // uint64_t CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR arg);
14851 export function CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(arg: bigint): bigint {
14852 if(!isWasmInitialized) {
14853 throw new Error("initializeWasm() must be awaited first!");
14855 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(arg);
14856 return nativeResponseValue;
14858 // struct LDKCResult_ChannelMonitorUpdateStatusNoneZ CResult_ChannelMonitorUpdateStatusNoneZ_clone(const struct LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR orig);
14860 export function CResult_ChannelMonitorUpdateStatusNoneZ_clone(orig: bigint): bigint {
14861 if(!isWasmInitialized) {
14862 throw new Error("initializeWasm() must be awaited first!");
14864 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone(orig);
14865 return nativeResponseValue;
14867 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
14869 export function CVec_MonitorEventZ_free(_res: number): void {
14870 if(!isWasmInitialized) {
14871 throw new Error("initializeWasm() must be awaited first!");
14873 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
14874 // debug statements here
14876 // uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
14878 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: bigint): bigint {
14879 if(!isWasmInitialized) {
14880 throw new Error("initializeWasm() must be awaited first!");
14882 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
14883 return nativeResponseValue;
14885 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
14887 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: bigint): bigint {
14888 if(!isWasmInitialized) {
14889 throw new Error("initializeWasm() must be awaited first!");
14891 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
14892 return nativeResponseValue;
14894 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
14896 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: bigint, b: number, c: number): bigint {
14897 if(!isWasmInitialized) {
14898 throw new Error("initializeWasm() must be awaited first!");
14900 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
14901 return nativeResponseValue;
14903 // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
14905 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: bigint): void {
14906 if(!isWasmInitialized) {
14907 throw new Error("initializeWasm() must be awaited first!");
14909 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
14910 // debug statements here
14912 // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
14914 export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
14915 if(!isWasmInitialized) {
14916 throw new Error("initializeWasm() must be awaited first!");
14918 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
14919 // debug statements here
14921 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
14923 export function CResult_InitFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14924 if(!isWasmInitialized) {
14925 throw new Error("initializeWasm() must be awaited first!");
14927 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
14928 return nativeResponseValue;
14930 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14932 export function CResult_InitFeaturesDecodeErrorZ_err(e: bigint): bigint {
14933 if(!isWasmInitialized) {
14934 throw new Error("initializeWasm() must be awaited first!");
14936 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
14937 return nativeResponseValue;
14939 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
14941 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14942 if(!isWasmInitialized) {
14943 throw new Error("initializeWasm() must be awaited first!");
14945 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
14946 return nativeResponseValue;
14948 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
14950 export function CResult_InitFeaturesDecodeErrorZ_free(_res: bigint): void {
14951 if(!isWasmInitialized) {
14952 throw new Error("initializeWasm() must be awaited first!");
14954 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
14955 // debug statements here
14957 // uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
14959 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
14960 if(!isWasmInitialized) {
14961 throw new Error("initializeWasm() must be awaited first!");
14963 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
14964 return nativeResponseValue;
14966 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
14968 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
14969 if(!isWasmInitialized) {
14970 throw new Error("initializeWasm() must be awaited first!");
14972 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
14973 return nativeResponseValue;
14975 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
14977 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: bigint): bigint {
14978 if(!isWasmInitialized) {
14979 throw new Error("initializeWasm() must be awaited first!");
14981 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
14982 return nativeResponseValue;
14984 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
14986 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: bigint): bigint {
14987 if(!isWasmInitialized) {
14988 throw new Error("initializeWasm() must be awaited first!");
14990 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
14991 return nativeResponseValue;
14993 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
14995 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
14996 if(!isWasmInitialized) {
14997 throw new Error("initializeWasm() must be awaited first!");
14999 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
15000 return nativeResponseValue;
15002 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
15004 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: bigint): void {
15005 if(!isWasmInitialized) {
15006 throw new Error("initializeWasm() must be awaited first!");
15008 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
15009 // debug statements here
15011 // uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
15013 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15014 if(!isWasmInitialized) {
15015 throw new Error("initializeWasm() must be awaited first!");
15017 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
15018 return nativeResponseValue;
15020 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
15022 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
15023 if(!isWasmInitialized) {
15024 throw new Error("initializeWasm() must be awaited first!");
15026 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
15027 return nativeResponseValue;
15029 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
15031 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
15032 if(!isWasmInitialized) {
15033 throw new Error("initializeWasm() must be awaited first!");
15035 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
15036 return nativeResponseValue;
15038 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
15040 export function CResult_NodeFeaturesDecodeErrorZ_err(e: bigint): bigint {
15041 if(!isWasmInitialized) {
15042 throw new Error("initializeWasm() must be awaited first!");
15044 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
15045 return nativeResponseValue;
15047 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
15049 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
15050 if(!isWasmInitialized) {
15051 throw new Error("initializeWasm() must be awaited first!");
15053 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
15054 return nativeResponseValue;
15056 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
15058 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: bigint): void {
15059 if(!isWasmInitialized) {
15060 throw new Error("initializeWasm() must be awaited first!");
15062 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
15063 // debug statements here
15065 // uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
15067 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15068 if(!isWasmInitialized) {
15069 throw new Error("initializeWasm() must be awaited first!");
15071 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
15072 return nativeResponseValue;
15074 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
15076 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
15077 if(!isWasmInitialized) {
15078 throw new Error("initializeWasm() must be awaited first!");
15080 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
15081 return nativeResponseValue;
15083 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt11InvoiceFeatures o);
15085 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
15086 if(!isWasmInitialized) {
15087 throw new Error("initializeWasm() must be awaited first!");
15089 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o);
15090 return nativeResponseValue;
15092 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
15094 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
15095 if(!isWasmInitialized) {
15096 throw new Error("initializeWasm() must be awaited first!");
15098 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e);
15099 return nativeResponseValue;
15101 // bool CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
15103 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
15104 if(!isWasmInitialized) {
15105 throw new Error("initializeWasm() must be awaited first!");
15107 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o);
15108 return nativeResponseValue;
15110 // void CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ _res);
15112 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
15113 if(!isWasmInitialized) {
15114 throw new Error("initializeWasm() must be awaited first!");
15116 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res);
15117 // debug statements here
15119 // uint64_t CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
15121 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15122 if(!isWasmInitialized) {
15123 throw new Error("initializeWasm() must be awaited first!");
15125 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
15126 return nativeResponseValue;
15128 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
15130 export function CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
15131 if(!isWasmInitialized) {
15132 throw new Error("initializeWasm() must be awaited first!");
15134 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig);
15135 return nativeResponseValue;
15137 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(struct LDKBolt12InvoiceFeatures o);
15139 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o: bigint): bigint {
15140 if(!isWasmInitialized) {
15141 throw new Error("initializeWasm() must be awaited first!");
15143 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o);
15144 return nativeResponseValue;
15146 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
15148 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e: bigint): bigint {
15149 if(!isWasmInitialized) {
15150 throw new Error("initializeWasm() must be awaited first!");
15152 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e);
15153 return nativeResponseValue;
15155 // bool CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
15157 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
15158 if(!isWasmInitialized) {
15159 throw new Error("initializeWasm() must be awaited first!");
15161 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o);
15162 return nativeResponseValue;
15164 // void CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ _res);
15166 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res: bigint): void {
15167 if(!isWasmInitialized) {
15168 throw new Error("initializeWasm() must be awaited first!");
15170 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res);
15171 // debug statements here
15173 // uint64_t CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
15175 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15176 if(!isWasmInitialized) {
15177 throw new Error("initializeWasm() must be awaited first!");
15179 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
15180 return nativeResponseValue;
15182 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
15184 export function CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
15185 if(!isWasmInitialized) {
15186 throw new Error("initializeWasm() must be awaited first!");
15188 const nativeResponseValue = wasm.TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig);
15189 return nativeResponseValue;
15191 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_ok(struct LDKBlindedHopFeatures o);
15193 export function CResult_BlindedHopFeaturesDecodeErrorZ_ok(o: bigint): bigint {
15194 if(!isWasmInitialized) {
15195 throw new Error("initializeWasm() must be awaited first!");
15197 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(o);
15198 return nativeResponseValue;
15200 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
15202 export function CResult_BlindedHopFeaturesDecodeErrorZ_err(e: bigint): bigint {
15203 if(!isWasmInitialized) {
15204 throw new Error("initializeWasm() must be awaited first!");
15206 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(e);
15207 return nativeResponseValue;
15209 // bool CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR o);
15211 export function CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
15212 if(!isWasmInitialized) {
15213 throw new Error("initializeWasm() must be awaited first!");
15215 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o);
15216 return nativeResponseValue;
15218 // void CResult_BlindedHopFeaturesDecodeErrorZ_free(struct LDKCResult_BlindedHopFeaturesDecodeErrorZ _res);
15220 export function CResult_BlindedHopFeaturesDecodeErrorZ_free(_res: bigint): void {
15221 if(!isWasmInitialized) {
15222 throw new Error("initializeWasm() must be awaited first!");
15224 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(_res);
15225 // debug statements here
15227 // uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg);
15229 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15230 if(!isWasmInitialized) {
15231 throw new Error("initializeWasm() must be awaited first!");
15233 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg);
15234 return nativeResponseValue;
15236 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ CResult_BlindedHopFeaturesDecodeErrorZ_clone(const struct LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR orig);
15238 export function CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
15239 if(!isWasmInitialized) {
15240 throw new Error("initializeWasm() must be awaited first!");
15242 const nativeResponseValue = wasm.TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig);
15243 return nativeResponseValue;
15245 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
15247 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: bigint): bigint {
15248 if(!isWasmInitialized) {
15249 throw new Error("initializeWasm() must be awaited first!");
15251 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
15252 return nativeResponseValue;
15254 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
15256 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: bigint): bigint {
15257 if(!isWasmInitialized) {
15258 throw new Error("initializeWasm() must be awaited first!");
15260 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
15261 return nativeResponseValue;
15263 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
15265 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: bigint): boolean {
15266 if(!isWasmInitialized) {
15267 throw new Error("initializeWasm() must be awaited first!");
15269 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
15270 return nativeResponseValue;
15272 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
15274 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: bigint): void {
15275 if(!isWasmInitialized) {
15276 throw new Error("initializeWasm() must be awaited first!");
15278 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
15279 // debug statements here
15281 // uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
15283 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15284 if(!isWasmInitialized) {
15285 throw new Error("initializeWasm() must be awaited first!");
15287 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
15288 return nativeResponseValue;
15290 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
15292 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: bigint): bigint {
15293 if(!isWasmInitialized) {
15294 throw new Error("initializeWasm() must be awaited first!");
15296 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
15297 return nativeResponseValue;
15299 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_ok(struct LDKOffer o);
15301 export function CResult_OfferBolt12ParseErrorZ_ok(o: bigint): bigint {
15302 if(!isWasmInitialized) {
15303 throw new Error("initializeWasm() must be awaited first!");
15305 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_ok(o);
15306 return nativeResponseValue;
15308 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
15310 export function CResult_OfferBolt12ParseErrorZ_err(e: bigint): bigint {
15311 if(!isWasmInitialized) {
15312 throw new Error("initializeWasm() must be awaited first!");
15314 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_err(e);
15315 return nativeResponseValue;
15317 // bool CResult_OfferBolt12ParseErrorZ_is_ok(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR o);
15319 export function CResult_OfferBolt12ParseErrorZ_is_ok(o: bigint): boolean {
15320 if(!isWasmInitialized) {
15321 throw new Error("initializeWasm() must be awaited first!");
15323 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_is_ok(o);
15324 return nativeResponseValue;
15326 // void CResult_OfferBolt12ParseErrorZ_free(struct LDKCResult_OfferBolt12ParseErrorZ _res);
15328 export function CResult_OfferBolt12ParseErrorZ_free(_res: bigint): void {
15329 if(!isWasmInitialized) {
15330 throw new Error("initializeWasm() must be awaited first!");
15332 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_free(_res);
15333 // debug statements here
15335 // uint64_t CResult_OfferBolt12ParseErrorZ_clone_ptr(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR arg);
15337 export function CResult_OfferBolt12ParseErrorZ_clone_ptr(arg: bigint): bigint {
15338 if(!isWasmInitialized) {
15339 throw new Error("initializeWasm() must be awaited first!");
15341 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone_ptr(arg);
15342 return nativeResponseValue;
15344 // struct LDKCResult_OfferBolt12ParseErrorZ CResult_OfferBolt12ParseErrorZ_clone(const struct LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR orig);
15346 export function CResult_OfferBolt12ParseErrorZ_clone(orig: bigint): bigint {
15347 if(!isWasmInitialized) {
15348 throw new Error("initializeWasm() must be awaited first!");
15350 const nativeResponseValue = wasm.TS_CResult_OfferBolt12ParseErrorZ_clone(orig);
15351 return nativeResponseValue;
15353 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_ok(struct LDKPublicKey o);
15355 export function CResult_PublicKeySecp256k1ErrorZ_ok(o: number): bigint {
15356 if(!isWasmInitialized) {
15357 throw new Error("initializeWasm() must be awaited first!");
15359 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_ok(o);
15360 return nativeResponseValue;
15362 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
15364 export function CResult_PublicKeySecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
15365 if(!isWasmInitialized) {
15366 throw new Error("initializeWasm() must be awaited first!");
15368 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_err(e);
15369 return nativeResponseValue;
15371 // bool CResult_PublicKeySecp256k1ErrorZ_is_ok(const struct LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR o);
15373 export function CResult_PublicKeySecp256k1ErrorZ_is_ok(o: bigint): boolean {
15374 if(!isWasmInitialized) {
15375 throw new Error("initializeWasm() must be awaited first!");
15377 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_is_ok(o);
15378 return nativeResponseValue;
15380 // void CResult_PublicKeySecp256k1ErrorZ_free(struct LDKCResult_PublicKeySecp256k1ErrorZ _res);
15382 export function CResult_PublicKeySecp256k1ErrorZ_free(_res: bigint): void {
15383 if(!isWasmInitialized) {
15384 throw new Error("initializeWasm() must be awaited first!");
15386 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_free(_res);
15387 // debug statements here
15389 // uint64_t CResult_PublicKeySecp256k1ErrorZ_clone_ptr(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR arg);
15391 export function CResult_PublicKeySecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
15392 if(!isWasmInitialized) {
15393 throw new Error("initializeWasm() must be awaited first!");
15395 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_clone_ptr(arg);
15396 return nativeResponseValue;
15398 // struct LDKCResult_PublicKeySecp256k1ErrorZ CResult_PublicKeySecp256k1ErrorZ_clone(const struct LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR orig);
15400 export function CResult_PublicKeySecp256k1ErrorZ_clone(orig: bigint): bigint {
15401 if(!isWasmInitialized) {
15402 throw new Error("initializeWasm() must be awaited first!");
15404 const nativeResponseValue = wasm.TS_CResult_PublicKeySecp256k1ErrorZ_clone(orig);
15405 return nativeResponseValue;
15407 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
15409 export function CResult_NodeIdDecodeErrorZ_ok(o: bigint): bigint {
15410 if(!isWasmInitialized) {
15411 throw new Error("initializeWasm() must be awaited first!");
15413 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
15414 return nativeResponseValue;
15416 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
15418 export function CResult_NodeIdDecodeErrorZ_err(e: bigint): bigint {
15419 if(!isWasmInitialized) {
15420 throw new Error("initializeWasm() must be awaited first!");
15422 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
15423 return nativeResponseValue;
15425 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
15427 export function CResult_NodeIdDecodeErrorZ_is_ok(o: bigint): boolean {
15428 if(!isWasmInitialized) {
15429 throw new Error("initializeWasm() must be awaited first!");
15431 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
15432 return nativeResponseValue;
15434 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
15436 export function CResult_NodeIdDecodeErrorZ_free(_res: bigint): void {
15437 if(!isWasmInitialized) {
15438 throw new Error("initializeWasm() must be awaited first!");
15440 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
15441 // debug statements here
15443 // uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
15445 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15446 if(!isWasmInitialized) {
15447 throw new Error("initializeWasm() must be awaited first!");
15449 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
15450 return nativeResponseValue;
15452 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
15454 export function CResult_NodeIdDecodeErrorZ_clone(orig: bigint): bigint {
15455 if(!isWasmInitialized) {
15456 throw new Error("initializeWasm() must be awaited first!");
15458 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
15459 return nativeResponseValue;
15461 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
15463 export function COption_NetworkUpdateZ_some(o: bigint): bigint {
15464 if(!isWasmInitialized) {
15465 throw new Error("initializeWasm() must be awaited first!");
15467 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
15468 return nativeResponseValue;
15470 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
15472 export function COption_NetworkUpdateZ_none(): bigint {
15473 if(!isWasmInitialized) {
15474 throw new Error("initializeWasm() must be awaited first!");
15476 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
15477 return nativeResponseValue;
15479 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
15481 export function COption_NetworkUpdateZ_free(_res: bigint): void {
15482 if(!isWasmInitialized) {
15483 throw new Error("initializeWasm() must be awaited first!");
15485 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
15486 // debug statements here
15488 // uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
15490 export function COption_NetworkUpdateZ_clone_ptr(arg: bigint): bigint {
15491 if(!isWasmInitialized) {
15492 throw new Error("initializeWasm() must be awaited first!");
15494 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
15495 return nativeResponseValue;
15497 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
15499 export function COption_NetworkUpdateZ_clone(orig: bigint): bigint {
15500 if(!isWasmInitialized) {
15501 throw new Error("initializeWasm() must be awaited first!");
15503 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
15504 return nativeResponseValue;
15506 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
15508 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: bigint): bigint {
15509 if(!isWasmInitialized) {
15510 throw new Error("initializeWasm() must be awaited first!");
15512 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
15513 return nativeResponseValue;
15515 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
15517 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: bigint): bigint {
15518 if(!isWasmInitialized) {
15519 throw new Error("initializeWasm() must be awaited first!");
15521 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
15522 return nativeResponseValue;
15524 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
15526 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: bigint): boolean {
15527 if(!isWasmInitialized) {
15528 throw new Error("initializeWasm() must be awaited first!");
15530 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
15531 return nativeResponseValue;
15533 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
15535 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: bigint): void {
15536 if(!isWasmInitialized) {
15537 throw new Error("initializeWasm() must be awaited first!");
15539 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
15540 // debug statements here
15542 // uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
15544 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15545 if(!isWasmInitialized) {
15546 throw new Error("initializeWasm() must be awaited first!");
15548 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
15549 return nativeResponseValue;
15551 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
15553 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: bigint): bigint {
15554 if(!isWasmInitialized) {
15555 throw new Error("initializeWasm() must be awaited first!");
15557 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
15558 return nativeResponseValue;
15560 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_some(struct LDKUtxoLookup o);
15562 export function COption_UtxoLookupZ_some(o: bigint): bigint {
15563 if(!isWasmInitialized) {
15564 throw new Error("initializeWasm() must be awaited first!");
15566 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_some(o);
15567 return nativeResponseValue;
15569 // struct LDKCOption_UtxoLookupZ COption_UtxoLookupZ_none(void);
15571 export function COption_UtxoLookupZ_none(): bigint {
15572 if(!isWasmInitialized) {
15573 throw new Error("initializeWasm() must be awaited first!");
15575 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_none();
15576 return nativeResponseValue;
15578 // void COption_UtxoLookupZ_free(struct LDKCOption_UtxoLookupZ _res);
15580 export function COption_UtxoLookupZ_free(_res: bigint): void {
15581 if(!isWasmInitialized) {
15582 throw new Error("initializeWasm() must be awaited first!");
15584 const nativeResponseValue = wasm.TS_COption_UtxoLookupZ_free(_res);
15585 // debug statements here
15587 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
15589 export function CResult_NoneLightningErrorZ_ok(): bigint {
15590 if(!isWasmInitialized) {
15591 throw new Error("initializeWasm() must be awaited first!");
15593 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
15594 return nativeResponseValue;
15596 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
15598 export function CResult_NoneLightningErrorZ_err(e: bigint): bigint {
15599 if(!isWasmInitialized) {
15600 throw new Error("initializeWasm() must be awaited first!");
15602 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
15603 return nativeResponseValue;
15605 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
15607 export function CResult_NoneLightningErrorZ_is_ok(o: bigint): boolean {
15608 if(!isWasmInitialized) {
15609 throw new Error("initializeWasm() must be awaited first!");
15611 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
15612 return nativeResponseValue;
15614 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
15616 export function CResult_NoneLightningErrorZ_free(_res: bigint): void {
15617 if(!isWasmInitialized) {
15618 throw new Error("initializeWasm() must be awaited first!");
15620 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
15621 // debug statements here
15623 // uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
15625 export function CResult_NoneLightningErrorZ_clone_ptr(arg: bigint): bigint {
15626 if(!isWasmInitialized) {
15627 throw new Error("initializeWasm() must be awaited first!");
15629 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
15630 return nativeResponseValue;
15632 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
15634 export function CResult_NoneLightningErrorZ_clone(orig: bigint): bigint {
15635 if(!isWasmInitialized) {
15636 throw new Error("initializeWasm() must be awaited first!");
15638 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
15639 return nativeResponseValue;
15641 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
15643 export function CResult_boolLightningErrorZ_ok(o: boolean): bigint {
15644 if(!isWasmInitialized) {
15645 throw new Error("initializeWasm() must be awaited first!");
15647 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
15648 return nativeResponseValue;
15650 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
15652 export function CResult_boolLightningErrorZ_err(e: bigint): bigint {
15653 if(!isWasmInitialized) {
15654 throw new Error("initializeWasm() must be awaited first!");
15656 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
15657 return nativeResponseValue;
15659 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
15661 export function CResult_boolLightningErrorZ_is_ok(o: bigint): boolean {
15662 if(!isWasmInitialized) {
15663 throw new Error("initializeWasm() must be awaited first!");
15665 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
15666 return nativeResponseValue;
15668 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
15670 export function CResult_boolLightningErrorZ_free(_res: bigint): void {
15671 if(!isWasmInitialized) {
15672 throw new Error("initializeWasm() must be awaited first!");
15674 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
15675 // debug statements here
15677 // uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
15679 export function CResult_boolLightningErrorZ_clone_ptr(arg: bigint): bigint {
15680 if(!isWasmInitialized) {
15681 throw new Error("initializeWasm() must be awaited first!");
15683 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
15684 return nativeResponseValue;
15686 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
15688 export function CResult_boolLightningErrorZ_clone(orig: bigint): bigint {
15689 if(!isWasmInitialized) {
15690 throw new Error("initializeWasm() must be awaited first!");
15692 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
15693 return nativeResponseValue;
15695 // uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
15697 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: bigint): bigint {
15698 if(!isWasmInitialized) {
15699 throw new Error("initializeWasm() must be awaited first!");
15701 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
15702 return nativeResponseValue;
15704 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
15706 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: bigint): bigint {
15707 if(!isWasmInitialized) {
15708 throw new Error("initializeWasm() must be awaited first!");
15710 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
15711 return nativeResponseValue;
15713 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
15715 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: bigint, b: bigint, c: bigint): bigint {
15716 if(!isWasmInitialized) {
15717 throw new Error("initializeWasm() must be awaited first!");
15719 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
15720 return nativeResponseValue;
15722 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
15724 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: bigint): void {
15725 if(!isWasmInitialized) {
15726 throw new Error("initializeWasm() must be awaited first!");
15728 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
15729 // debug statements here
15731 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o);
15733 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o: bigint): bigint {
15734 if(!isWasmInitialized) {
15735 throw new Error("initializeWasm() must be awaited first!");
15737 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o);
15738 return nativeResponseValue;
15740 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(void);
15742 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none(): bigint {
15743 if(!isWasmInitialized) {
15744 throw new Error("initializeWasm() must be awaited first!");
15746 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
15747 return nativeResponseValue;
15749 // void COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
15751 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: bigint): void {
15752 if(!isWasmInitialized) {
15753 throw new Error("initializeWasm() must be awaited first!");
15755 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
15756 // debug statements here
15758 // uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg);
15760 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg: bigint): bigint {
15761 if(!isWasmInitialized) {
15762 throw new Error("initializeWasm() must be awaited first!");
15764 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg);
15765 return nativeResponseValue;
15767 // struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const struct LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR orig);
15769 export function COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig: bigint): bigint {
15770 if(!isWasmInitialized) {
15771 throw new Error("initializeWasm() must be awaited first!");
15773 const nativeResponseValue = wasm.TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig);
15774 return nativeResponseValue;
15776 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
15778 export function CVec_MessageSendEventZ_free(_res: number): void {
15779 if(!isWasmInitialized) {
15780 throw new Error("initializeWasm() must be awaited first!");
15782 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
15783 // debug statements here
15785 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
15787 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: bigint): bigint {
15788 if(!isWasmInitialized) {
15789 throw new Error("initializeWasm() must be awaited first!");
15791 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
15792 return nativeResponseValue;
15794 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
15796 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: bigint): bigint {
15797 if(!isWasmInitialized) {
15798 throw new Error("initializeWasm() must be awaited first!");
15800 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
15801 return nativeResponseValue;
15803 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
15805 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: bigint): boolean {
15806 if(!isWasmInitialized) {
15807 throw new Error("initializeWasm() must be awaited first!");
15809 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
15810 return nativeResponseValue;
15812 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
15814 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: bigint): void {
15815 if(!isWasmInitialized) {
15816 throw new Error("initializeWasm() must be awaited first!");
15818 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
15819 // debug statements here
15821 // uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
15823 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15824 if(!isWasmInitialized) {
15825 throw new Error("initializeWasm() must be awaited first!");
15827 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
15828 return nativeResponseValue;
15830 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
15832 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: bigint): bigint {
15833 if(!isWasmInitialized) {
15834 throw new Error("initializeWasm() must be awaited first!");
15836 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
15837 return nativeResponseValue;
15839 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
15841 export function CResult_ChannelInfoDecodeErrorZ_ok(o: bigint): bigint {
15842 if(!isWasmInitialized) {
15843 throw new Error("initializeWasm() must be awaited first!");
15845 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
15846 return nativeResponseValue;
15848 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
15850 export function CResult_ChannelInfoDecodeErrorZ_err(e: bigint): bigint {
15851 if(!isWasmInitialized) {
15852 throw new Error("initializeWasm() must be awaited first!");
15854 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
15855 return nativeResponseValue;
15857 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
15859 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: bigint): boolean {
15860 if(!isWasmInitialized) {
15861 throw new Error("initializeWasm() must be awaited first!");
15863 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
15864 return nativeResponseValue;
15866 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
15868 export function CResult_ChannelInfoDecodeErrorZ_free(_res: bigint): void {
15869 if(!isWasmInitialized) {
15870 throw new Error("initializeWasm() must be awaited first!");
15872 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
15873 // debug statements here
15875 // uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
15877 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15878 if(!isWasmInitialized) {
15879 throw new Error("initializeWasm() must be awaited first!");
15881 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
15882 return nativeResponseValue;
15884 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
15886 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: bigint): bigint {
15887 if(!isWasmInitialized) {
15888 throw new Error("initializeWasm() must be awaited first!");
15890 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
15891 return nativeResponseValue;
15893 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
15895 export function CResult_RoutingFeesDecodeErrorZ_ok(o: bigint): bigint {
15896 if(!isWasmInitialized) {
15897 throw new Error("initializeWasm() must be awaited first!");
15899 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
15900 return nativeResponseValue;
15902 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
15904 export function CResult_RoutingFeesDecodeErrorZ_err(e: bigint): bigint {
15905 if(!isWasmInitialized) {
15906 throw new Error("initializeWasm() must be awaited first!");
15908 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
15909 return nativeResponseValue;
15911 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
15913 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: bigint): boolean {
15914 if(!isWasmInitialized) {
15915 throw new Error("initializeWasm() must be awaited first!");
15917 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
15918 return nativeResponseValue;
15920 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
15922 export function CResult_RoutingFeesDecodeErrorZ_free(_res: bigint): void {
15923 if(!isWasmInitialized) {
15924 throw new Error("initializeWasm() must be awaited first!");
15926 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
15927 // debug statements here
15929 // uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
15931 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15932 if(!isWasmInitialized) {
15933 throw new Error("initializeWasm() must be awaited first!");
15935 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
15936 return nativeResponseValue;
15938 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
15940 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: bigint): bigint {
15941 if(!isWasmInitialized) {
15942 throw new Error("initializeWasm() must be awaited first!");
15944 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
15945 return nativeResponseValue;
15947 // void CVec_SocketAddressZ_free(struct LDKCVec_SocketAddressZ _res);
15949 export function CVec_SocketAddressZ_free(_res: number): void {
15950 if(!isWasmInitialized) {
15951 throw new Error("initializeWasm() must be awaited first!");
15953 const nativeResponseValue = wasm.TS_CVec_SocketAddressZ_free(_res);
15954 // debug statements here
15956 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
15958 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: bigint): bigint {
15959 if(!isWasmInitialized) {
15960 throw new Error("initializeWasm() must be awaited first!");
15962 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
15963 return nativeResponseValue;
15965 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
15967 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: bigint): bigint {
15968 if(!isWasmInitialized) {
15969 throw new Error("initializeWasm() must be awaited first!");
15971 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
15972 return nativeResponseValue;
15974 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
15976 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: bigint): boolean {
15977 if(!isWasmInitialized) {
15978 throw new Error("initializeWasm() must be awaited first!");
15980 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
15981 return nativeResponseValue;
15983 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
15985 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: bigint): void {
15986 if(!isWasmInitialized) {
15987 throw new Error("initializeWasm() must be awaited first!");
15989 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
15990 // debug statements here
15992 // uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
15994 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
15995 if(!isWasmInitialized) {
15996 throw new Error("initializeWasm() must be awaited first!");
15998 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
15999 return nativeResponseValue;
16001 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
16003 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: bigint): bigint {
16004 if(!isWasmInitialized) {
16005 throw new Error("initializeWasm() must be awaited first!");
16007 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
16008 return nativeResponseValue;
16010 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
16012 export function CResult_NodeAliasDecodeErrorZ_ok(o: bigint): bigint {
16013 if(!isWasmInitialized) {
16014 throw new Error("initializeWasm() must be awaited first!");
16016 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
16017 return nativeResponseValue;
16019 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
16021 export function CResult_NodeAliasDecodeErrorZ_err(e: bigint): bigint {
16022 if(!isWasmInitialized) {
16023 throw new Error("initializeWasm() must be awaited first!");
16025 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
16026 return nativeResponseValue;
16028 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
16030 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: bigint): boolean {
16031 if(!isWasmInitialized) {
16032 throw new Error("initializeWasm() must be awaited first!");
16034 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
16035 return nativeResponseValue;
16037 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
16039 export function CResult_NodeAliasDecodeErrorZ_free(_res: bigint): void {
16040 if(!isWasmInitialized) {
16041 throw new Error("initializeWasm() must be awaited first!");
16043 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
16044 // debug statements here
16046 // uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
16048 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16049 if(!isWasmInitialized) {
16050 throw new Error("initializeWasm() must be awaited first!");
16052 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
16053 return nativeResponseValue;
16055 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
16057 export function CResult_NodeAliasDecodeErrorZ_clone(orig: bigint): bigint {
16058 if(!isWasmInitialized) {
16059 throw new Error("initializeWasm() must be awaited first!");
16061 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
16062 return nativeResponseValue;
16064 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
16066 export function CResult_NodeInfoDecodeErrorZ_ok(o: bigint): bigint {
16067 if(!isWasmInitialized) {
16068 throw new Error("initializeWasm() must be awaited first!");
16070 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
16071 return nativeResponseValue;
16073 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
16075 export function CResult_NodeInfoDecodeErrorZ_err(e: bigint): bigint {
16076 if(!isWasmInitialized) {
16077 throw new Error("initializeWasm() must be awaited first!");
16079 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
16080 return nativeResponseValue;
16082 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
16084 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: bigint): boolean {
16085 if(!isWasmInitialized) {
16086 throw new Error("initializeWasm() must be awaited first!");
16088 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
16089 return nativeResponseValue;
16091 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
16093 export function CResult_NodeInfoDecodeErrorZ_free(_res: bigint): void {
16094 if(!isWasmInitialized) {
16095 throw new Error("initializeWasm() must be awaited first!");
16097 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
16098 // debug statements here
16100 // uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
16102 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
16103 if(!isWasmInitialized) {
16104 throw new Error("initializeWasm() must be awaited first!");
16106 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
16107 return nativeResponseValue;
16109 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
16111 export function CResult_NodeInfoDecodeErrorZ_clone(orig: bigint): bigint {
16112 if(!isWasmInitialized) {
16113 throw new Error("initializeWasm() must be awaited first!");
16115 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
16116 return nativeResponseValue;
16118 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
16120 export function CResult_NetworkGraphDecodeErrorZ_ok(o: bigint): bigint {
16121 if(!isWasmInitialized) {
16122 throw new Error("initializeWasm() must be awaited first!");
16124 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
16125 return nativeResponseValue;
16127 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
16129 export function CResult_NetworkGraphDecodeErrorZ_err(e: bigint): bigint {
16130 if(!isWasmInitialized) {
16131 throw new Error("initializeWasm() must be awaited first!");
16133 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
16134 return nativeResponseValue;
16136 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
16138 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: bigint): boolean {
16139 if(!isWasmInitialized) {
16140 throw new Error("initializeWasm() must be awaited first!");
16142 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
16143 return nativeResponseValue;
16145 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
16147 export function CResult_NetworkGraphDecodeErrorZ_free(_res: bigint): void {
16148 if(!isWasmInitialized) {
16149 throw new Error("initializeWasm() must be awaited first!");
16151 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
16152 // debug statements here
16154 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_some(struct LDKCVec_SocketAddressZ o);
16156 export function COption_CVec_SocketAddressZZ_some(o: number): bigint {
16157 if(!isWasmInitialized) {
16158 throw new Error("initializeWasm() must be awaited first!");
16160 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_some(o);
16161 return nativeResponseValue;
16163 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_none(void);
16165 export function COption_CVec_SocketAddressZZ_none(): bigint {
16166 if(!isWasmInitialized) {
16167 throw new Error("initializeWasm() must be awaited first!");
16169 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_none();
16170 return nativeResponseValue;
16172 // void COption_CVec_SocketAddressZZ_free(struct LDKCOption_CVec_SocketAddressZZ _res);
16174 export function COption_CVec_SocketAddressZZ_free(_res: bigint): void {
16175 if(!isWasmInitialized) {
16176 throw new Error("initializeWasm() must be awaited first!");
16178 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_free(_res);
16179 // debug statements here
16181 // uint64_t COption_CVec_SocketAddressZZ_clone_ptr(LDKCOption_CVec_SocketAddressZZ *NONNULL_PTR arg);
16183 export function COption_CVec_SocketAddressZZ_clone_ptr(arg: bigint): bigint {
16184 if(!isWasmInitialized) {
16185 throw new Error("initializeWasm() must be awaited first!");
16187 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_clone_ptr(arg);
16188 return nativeResponseValue;
16190 // struct LDKCOption_CVec_SocketAddressZZ COption_CVec_SocketAddressZZ_clone(const struct LDKCOption_CVec_SocketAddressZZ *NONNULL_PTR orig);
16192 export function COption_CVec_SocketAddressZZ_clone(orig: bigint): bigint {
16193 if(!isWasmInitialized) {
16194 throw new Error("initializeWasm() must be awaited first!");
16196 const nativeResponseValue = wasm.TS_COption_CVec_SocketAddressZZ_clone(orig);
16197 return nativeResponseValue;
16199 // struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ CResult_PendingHTLCInfoInboundHTLCErrZ_ok(struct LDKPendingHTLCInfo o);
16201 export function CResult_PendingHTLCInfoInboundHTLCErrZ_ok(o: bigint): bigint {
16202 if(!isWasmInitialized) {
16203 throw new Error("initializeWasm() must be awaited first!");
16205 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_ok(o);
16206 return nativeResponseValue;
16208 // struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ CResult_PendingHTLCInfoInboundHTLCErrZ_err(struct LDKInboundHTLCErr e);
16210 export function CResult_PendingHTLCInfoInboundHTLCErrZ_err(e: bigint): bigint {
16211 if(!isWasmInitialized) {
16212 throw new Error("initializeWasm() must be awaited first!");
16214 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_err(e);
16215 return nativeResponseValue;
16217 // bool CResult_PendingHTLCInfoInboundHTLCErrZ_is_ok(const struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ *NONNULL_PTR o);
16219 export function CResult_PendingHTLCInfoInboundHTLCErrZ_is_ok(o: bigint): boolean {
16220 if(!isWasmInitialized) {
16221 throw new Error("initializeWasm() must be awaited first!");
16223 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_is_ok(o);
16224 return nativeResponseValue;
16226 // void CResult_PendingHTLCInfoInboundHTLCErrZ_free(struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ _res);
16228 export function CResult_PendingHTLCInfoInboundHTLCErrZ_free(_res: bigint): void {
16229 if(!isWasmInitialized) {
16230 throw new Error("initializeWasm() must be awaited first!");
16232 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoInboundHTLCErrZ_free(_res);
16233 // debug statements here
16235 // void CVec_HTLCOutputInCommitmentZ_free(struct LDKCVec_HTLCOutputInCommitmentZ _res);
16237 export function CVec_HTLCOutputInCommitmentZ_free(_res: number): void {
16238 if(!isWasmInitialized) {
16239 throw new Error("initializeWasm() must be awaited first!");
16241 const nativeResponseValue = wasm.TS_CVec_HTLCOutputInCommitmentZ_free(_res);
16242 // debug statements here
16244 // void CVec_HTLCDescriptorZ_free(struct LDKCVec_HTLCDescriptorZ _res);
16246 export function CVec_HTLCDescriptorZ_free(_res: number): void {
16247 if(!isWasmInitialized) {
16248 throw new Error("initializeWasm() must be awaited first!");
16250 const nativeResponseValue = wasm.TS_CVec_HTLCDescriptorZ_free(_res);
16251 // debug statements here
16253 // void CVec_UtxoZ_free(struct LDKCVec_UtxoZ _res);
16255 export function CVec_UtxoZ_free(_res: number): void {
16256 if(!isWasmInitialized) {
16257 throw new Error("initializeWasm() must be awaited first!");
16259 const nativeResponseValue = wasm.TS_CVec_UtxoZ_free(_res);
16260 // debug statements here
16262 // struct LDKCOption_TxOutZ COption_TxOutZ_some(struct LDKTxOut o);
16264 export function COption_TxOutZ_some(o: bigint): bigint {
16265 if(!isWasmInitialized) {
16266 throw new Error("initializeWasm() must be awaited first!");
16268 const nativeResponseValue = wasm.TS_COption_TxOutZ_some(o);
16269 return nativeResponseValue;
16271 // struct LDKCOption_TxOutZ COption_TxOutZ_none(void);
16273 export function COption_TxOutZ_none(): bigint {
16274 if(!isWasmInitialized) {
16275 throw new Error("initializeWasm() must be awaited first!");
16277 const nativeResponseValue = wasm.TS_COption_TxOutZ_none();
16278 return nativeResponseValue;
16280 // void COption_TxOutZ_free(struct LDKCOption_TxOutZ _res);
16282 export function COption_TxOutZ_free(_res: bigint): void {
16283 if(!isWasmInitialized) {
16284 throw new Error("initializeWasm() must be awaited first!");
16286 const nativeResponseValue = wasm.TS_COption_TxOutZ_free(_res);
16287 // debug statements here
16289 // uint64_t COption_TxOutZ_clone_ptr(LDKCOption_TxOutZ *NONNULL_PTR arg);
16291 export function COption_TxOutZ_clone_ptr(arg: bigint): bigint {
16292 if(!isWasmInitialized) {
16293 throw new Error("initializeWasm() must be awaited first!");
16295 const nativeResponseValue = wasm.TS_COption_TxOutZ_clone_ptr(arg);
16296 return nativeResponseValue;
16298 // struct LDKCOption_TxOutZ COption_TxOutZ_clone(const struct LDKCOption_TxOutZ *NONNULL_PTR orig);
16300 export function COption_TxOutZ_clone(orig: bigint): bigint {
16301 if(!isWasmInitialized) {
16302 throw new Error("initializeWasm() must be awaited first!");
16304 const nativeResponseValue = wasm.TS_COption_TxOutZ_clone(orig);
16305 return nativeResponseValue;
16307 // void CVec_InputZ_free(struct LDKCVec_InputZ _res);
16309 export function CVec_InputZ_free(_res: number): void {
16310 if(!isWasmInitialized) {
16311 throw new Error("initializeWasm() must be awaited first!");
16313 const nativeResponseValue = wasm.TS_CVec_InputZ_free(_res);
16314 // debug statements here
16316 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_ok(struct LDKCoinSelection o);
16318 export function CResult_CoinSelectionNoneZ_ok(o: bigint): bigint {
16319 if(!isWasmInitialized) {
16320 throw new Error("initializeWasm() must be awaited first!");
16322 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_ok(o);
16323 return nativeResponseValue;
16325 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_err(void);
16327 export function CResult_CoinSelectionNoneZ_err(): bigint {
16328 if(!isWasmInitialized) {
16329 throw new Error("initializeWasm() must be awaited first!");
16331 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_err();
16332 return nativeResponseValue;
16334 // bool CResult_CoinSelectionNoneZ_is_ok(const struct LDKCResult_CoinSelectionNoneZ *NONNULL_PTR o);
16336 export function CResult_CoinSelectionNoneZ_is_ok(o: bigint): boolean {
16337 if(!isWasmInitialized) {
16338 throw new Error("initializeWasm() must be awaited first!");
16340 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_is_ok(o);
16341 return nativeResponseValue;
16343 // void CResult_CoinSelectionNoneZ_free(struct LDKCResult_CoinSelectionNoneZ _res);
16345 export function CResult_CoinSelectionNoneZ_free(_res: bigint): void {
16346 if(!isWasmInitialized) {
16347 throw new Error("initializeWasm() must be awaited first!");
16349 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_free(_res);
16350 // debug statements here
16352 // uint64_t CResult_CoinSelectionNoneZ_clone_ptr(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR arg);
16354 export function CResult_CoinSelectionNoneZ_clone_ptr(arg: bigint): bigint {
16355 if(!isWasmInitialized) {
16356 throw new Error("initializeWasm() must be awaited first!");
16358 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_clone_ptr(arg);
16359 return nativeResponseValue;
16361 // struct LDKCResult_CoinSelectionNoneZ CResult_CoinSelectionNoneZ_clone(const struct LDKCResult_CoinSelectionNoneZ *NONNULL_PTR orig);
16363 export function CResult_CoinSelectionNoneZ_clone(orig: bigint): bigint {
16364 if(!isWasmInitialized) {
16365 throw new Error("initializeWasm() must be awaited first!");
16367 const nativeResponseValue = wasm.TS_CResult_CoinSelectionNoneZ_clone(orig);
16368 return nativeResponseValue;
16370 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_ok(struct LDKCVec_UtxoZ o);
16372 export function CResult_CVec_UtxoZNoneZ_ok(o: number): bigint {
16373 if(!isWasmInitialized) {
16374 throw new Error("initializeWasm() must be awaited first!");
16376 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_ok(o);
16377 return nativeResponseValue;
16379 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_err(void);
16381 export function CResult_CVec_UtxoZNoneZ_err(): bigint {
16382 if(!isWasmInitialized) {
16383 throw new Error("initializeWasm() must be awaited first!");
16385 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_err();
16386 return nativeResponseValue;
16388 // bool CResult_CVec_UtxoZNoneZ_is_ok(const struct LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR o);
16390 export function CResult_CVec_UtxoZNoneZ_is_ok(o: bigint): boolean {
16391 if(!isWasmInitialized) {
16392 throw new Error("initializeWasm() must be awaited first!");
16394 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_is_ok(o);
16395 return nativeResponseValue;
16397 // void CResult_CVec_UtxoZNoneZ_free(struct LDKCResult_CVec_UtxoZNoneZ _res);
16399 export function CResult_CVec_UtxoZNoneZ_free(_res: bigint): void {
16400 if(!isWasmInitialized) {
16401 throw new Error("initializeWasm() must be awaited first!");
16403 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_free(_res);
16404 // debug statements here
16406 // uint64_t CResult_CVec_UtxoZNoneZ_clone_ptr(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR arg);
16408 export function CResult_CVec_UtxoZNoneZ_clone_ptr(arg: bigint): bigint {
16409 if(!isWasmInitialized) {
16410 throw new Error("initializeWasm() must be awaited first!");
16412 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_clone_ptr(arg);
16413 return nativeResponseValue;
16415 // struct LDKCResult_CVec_UtxoZNoneZ CResult_CVec_UtxoZNoneZ_clone(const struct LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR orig);
16417 export function CResult_CVec_UtxoZNoneZ_clone(orig: bigint): bigint {
16418 if(!isWasmInitialized) {
16419 throw new Error("initializeWasm() must be awaited first!");
16421 const nativeResponseValue = wasm.TS_CResult_CVec_UtxoZNoneZ_clone(orig);
16422 return nativeResponseValue;
16424 // uint64_t C2Tuple_u64u16Z_clone_ptr(LDKC2Tuple_u64u16Z *NONNULL_PTR arg);
16426 export function C2Tuple_u64u16Z_clone_ptr(arg: bigint): bigint {
16427 if(!isWasmInitialized) {
16428 throw new Error("initializeWasm() must be awaited first!");
16430 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_clone_ptr(arg);
16431 return nativeResponseValue;
16433 // struct LDKC2Tuple_u64u16Z C2Tuple_u64u16Z_clone(const struct LDKC2Tuple_u64u16Z *NONNULL_PTR orig);
16435 export function C2Tuple_u64u16Z_clone(orig: bigint): bigint {
16436 if(!isWasmInitialized) {
16437 throw new Error("initializeWasm() must be awaited first!");
16439 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_clone(orig);
16440 return nativeResponseValue;
16442 // struct LDKC2Tuple_u64u16Z C2Tuple_u64u16Z_new(uint64_t a, uint16_t b);
16444 export function C2Tuple_u64u16Z_new(a: bigint, b: number): bigint {
16445 if(!isWasmInitialized) {
16446 throw new Error("initializeWasm() must be awaited first!");
16448 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_new(a, b);
16449 return nativeResponseValue;
16451 // void C2Tuple_u64u16Z_free(struct LDKC2Tuple_u64u16Z _res);
16453 export function C2Tuple_u64u16Z_free(_res: bigint): void {
16454 if(!isWasmInitialized) {
16455 throw new Error("initializeWasm() must be awaited first!");
16457 const nativeResponseValue = wasm.TS_C2Tuple_u64u16Z_free(_res);
16458 // debug statements here
16460 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_some(struct LDKC2Tuple_u64u16Z o);
16462 export function COption_C2Tuple_u64u16ZZ_some(o: bigint): bigint {
16463 if(!isWasmInitialized) {
16464 throw new Error("initializeWasm() must be awaited first!");
16466 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_some(o);
16467 return nativeResponseValue;
16469 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_none(void);
16471 export function COption_C2Tuple_u64u16ZZ_none(): bigint {
16472 if(!isWasmInitialized) {
16473 throw new Error("initializeWasm() must be awaited first!");
16475 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_none();
16476 return nativeResponseValue;
16478 // void COption_C2Tuple_u64u16ZZ_free(struct LDKCOption_C2Tuple_u64u16ZZ _res);
16480 export function COption_C2Tuple_u64u16ZZ_free(_res: bigint): void {
16481 if(!isWasmInitialized) {
16482 throw new Error("initializeWasm() must be awaited first!");
16484 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_free(_res);
16485 // debug statements here
16487 // uint64_t COption_C2Tuple_u64u16ZZ_clone_ptr(LDKCOption_C2Tuple_u64u16ZZ *NONNULL_PTR arg);
16489 export function COption_C2Tuple_u64u16ZZ_clone_ptr(arg: bigint): bigint {
16490 if(!isWasmInitialized) {
16491 throw new Error("initializeWasm() must be awaited first!");
16493 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_clone_ptr(arg);
16494 return nativeResponseValue;
16496 // struct LDKCOption_C2Tuple_u64u16ZZ COption_C2Tuple_u64u16ZZ_clone(const struct LDKCOption_C2Tuple_u64u16ZZ *NONNULL_PTR orig);
16498 export function COption_C2Tuple_u64u16ZZ_clone(orig: bigint): bigint {
16499 if(!isWasmInitialized) {
16500 throw new Error("initializeWasm() must be awaited first!");
16502 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_clone(orig);
16503 return nativeResponseValue;
16505 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_some(enum LDKChannelShutdownState o);
16507 export function COption_ChannelShutdownStateZ_some(o: ChannelShutdownState): bigint {
16508 if(!isWasmInitialized) {
16509 throw new Error("initializeWasm() must be awaited first!");
16511 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_some(o);
16512 return nativeResponseValue;
16514 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_none(void);
16516 export function COption_ChannelShutdownStateZ_none(): bigint {
16517 if(!isWasmInitialized) {
16518 throw new Error("initializeWasm() must be awaited first!");
16520 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_none();
16521 return nativeResponseValue;
16523 // void COption_ChannelShutdownStateZ_free(struct LDKCOption_ChannelShutdownStateZ _res);
16525 export function COption_ChannelShutdownStateZ_free(_res: bigint): void {
16526 if(!isWasmInitialized) {
16527 throw new Error("initializeWasm() must be awaited first!");
16529 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_free(_res);
16530 // debug statements here
16532 // uint64_t COption_ChannelShutdownStateZ_clone_ptr(LDKCOption_ChannelShutdownStateZ *NONNULL_PTR arg);
16534 export function COption_ChannelShutdownStateZ_clone_ptr(arg: bigint): bigint {
16535 if(!isWasmInitialized) {
16536 throw new Error("initializeWasm() must be awaited first!");
16538 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone_ptr(arg);
16539 return nativeResponseValue;
16541 // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_clone(const struct LDKCOption_ChannelShutdownStateZ *NONNULL_PTR orig);
16543 export function COption_ChannelShutdownStateZ_clone(orig: bigint): bigint {
16544 if(!isWasmInitialized) {
16545 throw new Error("initializeWasm() must be awaited first!");
16547 const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone(orig);
16548 return nativeResponseValue;
16550 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
16552 export function CResult_ThirtyTwoBytesAPIErrorZ_ok(o: number): bigint {
16553 if(!isWasmInitialized) {
16554 throw new Error("initializeWasm() must be awaited first!");
16556 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_ok(o);
16557 return nativeResponseValue;
16559 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_err(struct LDKAPIError e);
16561 export function CResult_ThirtyTwoBytesAPIErrorZ_err(e: bigint): bigint {
16562 if(!isWasmInitialized) {
16563 throw new Error("initializeWasm() must be awaited first!");
16565 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_err(e);
16566 return nativeResponseValue;
16568 // bool CResult_ThirtyTwoBytesAPIErrorZ_is_ok(const struct LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR o);
16570 export function CResult_ThirtyTwoBytesAPIErrorZ_is_ok(o: bigint): boolean {
16571 if(!isWasmInitialized) {
16572 throw new Error("initializeWasm() must be awaited first!");
16574 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_is_ok(o);
16575 return nativeResponseValue;
16577 // void CResult_ThirtyTwoBytesAPIErrorZ_free(struct LDKCResult_ThirtyTwoBytesAPIErrorZ _res);
16579 export function CResult_ThirtyTwoBytesAPIErrorZ_free(_res: bigint): void {
16580 if(!isWasmInitialized) {
16581 throw new Error("initializeWasm() must be awaited first!");
16583 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_free(_res);
16584 // debug statements here
16586 // uint64_t CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR arg);
16588 export function CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(arg: bigint): bigint {
16589 if(!isWasmInitialized) {
16590 throw new Error("initializeWasm() must be awaited first!");
16592 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(arg);
16593 return nativeResponseValue;
16595 // struct LDKCResult_ThirtyTwoBytesAPIErrorZ CResult_ThirtyTwoBytesAPIErrorZ_clone(const struct LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR orig);
16597 export function CResult_ThirtyTwoBytesAPIErrorZ_clone(orig: bigint): bigint {
16598 if(!isWasmInitialized) {
16599 throw new Error("initializeWasm() must be awaited first!");
16601 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesAPIErrorZ_clone(orig);
16602 return nativeResponseValue;
16604 // void CVec_RecentPaymentDetailsZ_free(struct LDKCVec_RecentPaymentDetailsZ _res);
16606 export function CVec_RecentPaymentDetailsZ_free(_res: number): void {
16607 if(!isWasmInitialized) {
16608 throw new Error("initializeWasm() must be awaited first!");
16610 const nativeResponseValue = wasm.TS_CVec_RecentPaymentDetailsZ_free(_res);
16611 // debug statements here
16613 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
16615 export function CResult_NonePaymentSendFailureZ_ok(): bigint {
16616 if(!isWasmInitialized) {
16617 throw new Error("initializeWasm() must be awaited first!");
16619 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
16620 return nativeResponseValue;
16622 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
16624 export function CResult_NonePaymentSendFailureZ_err(e: bigint): bigint {
16625 if(!isWasmInitialized) {
16626 throw new Error("initializeWasm() must be awaited first!");
16628 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
16629 return nativeResponseValue;
16631 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
16633 export function CResult_NonePaymentSendFailureZ_is_ok(o: bigint): boolean {
16634 if(!isWasmInitialized) {
16635 throw new Error("initializeWasm() must be awaited first!");
16637 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
16638 return nativeResponseValue;
16640 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
16642 export function CResult_NonePaymentSendFailureZ_free(_res: bigint): void {
16643 if(!isWasmInitialized) {
16644 throw new Error("initializeWasm() must be awaited first!");
16646 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
16647 // debug statements here
16649 // uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
16651 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
16652 if(!isWasmInitialized) {
16653 throw new Error("initializeWasm() must be awaited first!");
16655 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
16656 return nativeResponseValue;
16658 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
16660 export function CResult_NonePaymentSendFailureZ_clone(orig: bigint): bigint {
16661 if(!isWasmInitialized) {
16662 throw new Error("initializeWasm() must be awaited first!");
16664 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
16665 return nativeResponseValue;
16667 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_ok(void);
16669 export function CResult_NoneRetryableSendFailureZ_ok(): bigint {
16670 if(!isWasmInitialized) {
16671 throw new Error("initializeWasm() must be awaited first!");
16673 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_ok();
16674 return nativeResponseValue;
16676 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
16678 export function CResult_NoneRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
16679 if(!isWasmInitialized) {
16680 throw new Error("initializeWasm() must be awaited first!");
16682 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_err(e);
16683 return nativeResponseValue;
16685 // bool CResult_NoneRetryableSendFailureZ_is_ok(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR o);
16687 export function CResult_NoneRetryableSendFailureZ_is_ok(o: bigint): boolean {
16688 if(!isWasmInitialized) {
16689 throw new Error("initializeWasm() must be awaited first!");
16691 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_is_ok(o);
16692 return nativeResponseValue;
16694 // void CResult_NoneRetryableSendFailureZ_free(struct LDKCResult_NoneRetryableSendFailureZ _res);
16696 export function CResult_NoneRetryableSendFailureZ_free(_res: bigint): void {
16697 if(!isWasmInitialized) {
16698 throw new Error("initializeWasm() must be awaited first!");
16700 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_free(_res);
16701 // debug statements here
16703 // uint64_t CResult_NoneRetryableSendFailureZ_clone_ptr(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR arg);
16705 export function CResult_NoneRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
16706 if(!isWasmInitialized) {
16707 throw new Error("initializeWasm() must be awaited first!");
16709 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone_ptr(arg);
16710 return nativeResponseValue;
16712 // struct LDKCResult_NoneRetryableSendFailureZ CResult_NoneRetryableSendFailureZ_clone(const struct LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR orig);
16714 export function CResult_NoneRetryableSendFailureZ_clone(orig: bigint): bigint {
16715 if(!isWasmInitialized) {
16716 throw new Error("initializeWasm() must be awaited first!");
16718 const nativeResponseValue = wasm.TS_CResult_NoneRetryableSendFailureZ_clone(orig);
16719 return nativeResponseValue;
16721 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
16723 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(o: number): bigint {
16724 if(!isWasmInitialized) {
16725 throw new Error("initializeWasm() must be awaited first!");
16727 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(o);
16728 return nativeResponseValue;
16730 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
16732 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_err(e: bigint): bigint {
16733 if(!isWasmInitialized) {
16734 throw new Error("initializeWasm() must be awaited first!");
16736 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_err(e);
16737 return nativeResponseValue;
16739 // bool CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(const struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR o);
16741 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(o: bigint): boolean {
16742 if(!isWasmInitialized) {
16743 throw new Error("initializeWasm() must be awaited first!");
16745 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(o);
16746 return nativeResponseValue;
16748 // void CResult_ThirtyTwoBytesPaymentSendFailureZ_free(struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ _res);
16750 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_free(_res: bigint): void {
16751 if(!isWasmInitialized) {
16752 throw new Error("initializeWasm() must be awaited first!");
16754 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_free(_res);
16755 // debug statements here
16757 // uint64_t CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR arg);
16759 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
16760 if(!isWasmInitialized) {
16761 throw new Error("initializeWasm() must be awaited first!");
16763 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(arg);
16764 return nativeResponseValue;
16766 // struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(const struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR orig);
16768 export function CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(orig: bigint): bigint {
16769 if(!isWasmInitialized) {
16770 throw new Error("initializeWasm() must be awaited first!");
16772 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(orig);
16773 return nativeResponseValue;
16775 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(struct LDKThirtyTwoBytes o);
16777 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(o: number): bigint {
16778 if(!isWasmInitialized) {
16779 throw new Error("initializeWasm() must be awaited first!");
16781 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(o);
16782 return nativeResponseValue;
16784 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_err(enum LDKRetryableSendFailure e);
16786 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_err(e: RetryableSendFailure): bigint {
16787 if(!isWasmInitialized) {
16788 throw new Error("initializeWasm() must be awaited first!");
16790 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_err(e);
16791 return nativeResponseValue;
16793 // bool CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(const struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR o);
16795 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(o: bigint): boolean {
16796 if(!isWasmInitialized) {
16797 throw new Error("initializeWasm() must be awaited first!");
16799 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(o);
16800 return nativeResponseValue;
16802 // void CResult_ThirtyTwoBytesRetryableSendFailureZ_free(struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ _res);
16804 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_free(_res: bigint): void {
16805 if(!isWasmInitialized) {
16806 throw new Error("initializeWasm() must be awaited first!");
16808 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_free(_res);
16809 // debug statements here
16811 // uint64_t CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR arg);
16813 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(arg: bigint): bigint {
16814 if(!isWasmInitialized) {
16815 throw new Error("initializeWasm() must be awaited first!");
16817 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(arg);
16818 return nativeResponseValue;
16820 // struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(const struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR orig);
16822 export function CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(orig: bigint): bigint {
16823 if(!isWasmInitialized) {
16824 throw new Error("initializeWasm() must be awaited first!");
16826 const nativeResponseValue = wasm.TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(orig);
16827 return nativeResponseValue;
16829 // uint64_t C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR arg);
16831 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(arg: bigint): bigint {
16832 if(!isWasmInitialized) {
16833 throw new Error("initializeWasm() must be awaited first!");
16835 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(arg);
16836 return nativeResponseValue;
16838 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR orig);
16840 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(orig: bigint): bigint {
16841 if(!isWasmInitialized) {
16842 throw new Error("initializeWasm() must be awaited first!");
16844 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(orig);
16845 return nativeResponseValue;
16847 // struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
16849 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(a: number, b: number): bigint {
16850 if(!isWasmInitialized) {
16851 throw new Error("initializeWasm() must be awaited first!");
16853 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(a, b);
16854 return nativeResponseValue;
16856 // void C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ _res);
16858 export function C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(_res: bigint): void {
16859 if(!isWasmInitialized) {
16860 throw new Error("initializeWasm() must be awaited first!");
16862 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(_res);
16863 // debug statements here
16865 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o);
16867 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(o: bigint): bigint {
16868 if(!isWasmInitialized) {
16869 throw new Error("initializeWasm() must be awaited first!");
16871 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(o);
16872 return nativeResponseValue;
16874 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
16876 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(e: bigint): bigint {
16877 if(!isWasmInitialized) {
16878 throw new Error("initializeWasm() must be awaited first!");
16880 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(e);
16881 return nativeResponseValue;
16883 // bool CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR o);
16885 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(o: bigint): boolean {
16886 if(!isWasmInitialized) {
16887 throw new Error("initializeWasm() must be awaited first!");
16889 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(o);
16890 return nativeResponseValue;
16892 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ _res);
16894 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(_res: bigint): void {
16895 if(!isWasmInitialized) {
16896 throw new Error("initializeWasm() must be awaited first!");
16898 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(_res);
16899 // debug statements here
16901 // uint64_t CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR arg);
16903 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(arg: bigint): bigint {
16904 if(!isWasmInitialized) {
16905 throw new Error("initializeWasm() must be awaited first!");
16907 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(arg);
16908 return nativeResponseValue;
16910 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR orig);
16912 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(orig: bigint): bigint {
16913 if(!isWasmInitialized) {
16914 throw new Error("initializeWasm() must be awaited first!");
16916 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(orig);
16917 return nativeResponseValue;
16919 // void CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ _res);
16921 export function CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(_res: number): void {
16922 if(!isWasmInitialized) {
16923 throw new Error("initializeWasm() must be awaited first!");
16925 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(_res);
16926 // debug statements here
16928 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ o);
16930 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(o: number): bigint {
16931 if(!isWasmInitialized) {
16932 throw new Error("initializeWasm() must be awaited first!");
16934 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(o);
16935 return nativeResponseValue;
16937 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(struct LDKProbeSendFailure e);
16939 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(e: bigint): bigint {
16940 if(!isWasmInitialized) {
16941 throw new Error("initializeWasm() must be awaited first!");
16943 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(e);
16944 return nativeResponseValue;
16946 // bool CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR o);
16948 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(o: bigint): boolean {
16949 if(!isWasmInitialized) {
16950 throw new Error("initializeWasm() must be awaited first!");
16952 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(o);
16953 return nativeResponseValue;
16955 // void CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ _res);
16957 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(_res: bigint): void {
16958 if(!isWasmInitialized) {
16959 throw new Error("initializeWasm() must be awaited first!");
16961 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(_res);
16962 // debug statements here
16964 // uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR arg);
16966 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(arg: bigint): bigint {
16967 if(!isWasmInitialized) {
16968 throw new Error("initializeWasm() must be awaited first!");
16970 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(arg);
16971 return nativeResponseValue;
16973 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR orig);
16975 export function CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(orig: bigint): bigint {
16976 if(!isWasmInitialized) {
16977 throw new Error("initializeWasm() must be awaited first!");
16979 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(orig);
16980 return nativeResponseValue;
16982 // uint64_t C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR arg);
16984 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(arg: bigint): bigint {
16985 if(!isWasmInitialized) {
16986 throw new Error("initializeWasm() must be awaited first!");
16988 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(arg);
16989 return nativeResponseValue;
16991 // struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR orig);
16993 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(orig: bigint): bigint {
16994 if(!isWasmInitialized) {
16995 throw new Error("initializeWasm() must be awaited first!");
16997 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(orig);
16998 return nativeResponseValue;
17000 // struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ C2Tuple_ThirtyTwoBytesPublicKeyZ_new(struct LDKThirtyTwoBytes a, struct LDKPublicKey b);
17002 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_new(a: number, b: number): bigint {
17003 if(!isWasmInitialized) {
17004 throw new Error("initializeWasm() must be awaited first!");
17006 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_new(a, b);
17007 return nativeResponseValue;
17009 // void C2Tuple_ThirtyTwoBytesPublicKeyZ_free(struct LDKC2Tuple_ThirtyTwoBytesPublicKeyZ _res);
17011 export function C2Tuple_ThirtyTwoBytesPublicKeyZ_free(_res: bigint): void {
17012 if(!isWasmInitialized) {
17013 throw new Error("initializeWasm() must be awaited first!");
17015 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_free(_res);
17016 // debug statements here
17018 // void CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ _res);
17020 export function CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(_res: number): void {
17021 if(!isWasmInitialized) {
17022 throw new Error("initializeWasm() must be awaited first!");
17024 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(_res);
17025 // debug statements here
17027 // struct LDKCOption_StrZ COption_StrZ_some(struct LDKStr o);
17029 export function COption_StrZ_some(o: number): bigint {
17030 if(!isWasmInitialized) {
17031 throw new Error("initializeWasm() must be awaited first!");
17033 const nativeResponseValue = wasm.TS_COption_StrZ_some(o);
17034 return nativeResponseValue;
17036 // struct LDKCOption_StrZ COption_StrZ_none(void);
17038 export function COption_StrZ_none(): bigint {
17039 if(!isWasmInitialized) {
17040 throw new Error("initializeWasm() must be awaited first!");
17042 const nativeResponseValue = wasm.TS_COption_StrZ_none();
17043 return nativeResponseValue;
17045 // void COption_StrZ_free(struct LDKCOption_StrZ _res);
17047 export function COption_StrZ_free(_res: bigint): void {
17048 if(!isWasmInitialized) {
17049 throw new Error("initializeWasm() must be awaited first!");
17051 const nativeResponseValue = wasm.TS_COption_StrZ_free(_res);
17052 // debug statements here
17054 // uint64_t COption_StrZ_clone_ptr(LDKCOption_StrZ *NONNULL_PTR arg);
17056 export function COption_StrZ_clone_ptr(arg: bigint): bigint {
17057 if(!isWasmInitialized) {
17058 throw new Error("initializeWasm() must be awaited first!");
17060 const nativeResponseValue = wasm.TS_COption_StrZ_clone_ptr(arg);
17061 return nativeResponseValue;
17063 // struct LDKCOption_StrZ COption_StrZ_clone(const struct LDKCOption_StrZ *NONNULL_PTR orig);
17065 export function COption_StrZ_clone(orig: bigint): bigint {
17066 if(!isWasmInitialized) {
17067 throw new Error("initializeWasm() must be awaited first!");
17069 const nativeResponseValue = wasm.TS_COption_StrZ_clone(orig);
17070 return nativeResponseValue;
17072 // struct LDKCResult_NoneBolt12SemanticErrorZ CResult_NoneBolt12SemanticErrorZ_ok(void);
17074 export function CResult_NoneBolt12SemanticErrorZ_ok(): bigint {
17075 if(!isWasmInitialized) {
17076 throw new Error("initializeWasm() must be awaited first!");
17078 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_ok();
17079 return nativeResponseValue;
17081 // struct LDKCResult_NoneBolt12SemanticErrorZ CResult_NoneBolt12SemanticErrorZ_err(enum LDKBolt12SemanticError e);
17083 export function CResult_NoneBolt12SemanticErrorZ_err(e: Bolt12SemanticError): bigint {
17084 if(!isWasmInitialized) {
17085 throw new Error("initializeWasm() must be awaited first!");
17087 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_err(e);
17088 return nativeResponseValue;
17090 // bool CResult_NoneBolt12SemanticErrorZ_is_ok(const struct LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR o);
17092 export function CResult_NoneBolt12SemanticErrorZ_is_ok(o: bigint): boolean {
17093 if(!isWasmInitialized) {
17094 throw new Error("initializeWasm() must be awaited first!");
17096 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_is_ok(o);
17097 return nativeResponseValue;
17099 // void CResult_NoneBolt12SemanticErrorZ_free(struct LDKCResult_NoneBolt12SemanticErrorZ _res);
17101 export function CResult_NoneBolt12SemanticErrorZ_free(_res: bigint): void {
17102 if(!isWasmInitialized) {
17103 throw new Error("initializeWasm() must be awaited first!");
17105 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_free(_res);
17106 // debug statements here
17108 // uint64_t CResult_NoneBolt12SemanticErrorZ_clone_ptr(LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR arg);
17110 export function CResult_NoneBolt12SemanticErrorZ_clone_ptr(arg: bigint): bigint {
17111 if(!isWasmInitialized) {
17112 throw new Error("initializeWasm() must be awaited first!");
17114 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_clone_ptr(arg);
17115 return nativeResponseValue;
17117 // struct LDKCResult_NoneBolt12SemanticErrorZ CResult_NoneBolt12SemanticErrorZ_clone(const struct LDKCResult_NoneBolt12SemanticErrorZ *NONNULL_PTR orig);
17119 export function CResult_NoneBolt12SemanticErrorZ_clone(orig: bigint): bigint {
17120 if(!isWasmInitialized) {
17121 throw new Error("initializeWasm() must be awaited first!");
17123 const nativeResponseValue = wasm.TS_CResult_NoneBolt12SemanticErrorZ_clone(orig);
17124 return nativeResponseValue;
17126 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o);
17128 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(o: bigint): bigint {
17129 if(!isWasmInitialized) {
17130 throw new Error("initializeWasm() must be awaited first!");
17132 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(o);
17133 return nativeResponseValue;
17135 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err(void);
17137 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err(): bigint {
17138 if(!isWasmInitialized) {
17139 throw new Error("initializeWasm() must be awaited first!");
17141 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err();
17142 return nativeResponseValue;
17144 // bool CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR o);
17146 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(o: bigint): boolean {
17147 if(!isWasmInitialized) {
17148 throw new Error("initializeWasm() must be awaited first!");
17150 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(o);
17151 return nativeResponseValue;
17153 // void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ _res);
17155 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(_res: bigint): void {
17156 if(!isWasmInitialized) {
17157 throw new Error("initializeWasm() must be awaited first!");
17159 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(_res);
17160 // debug statements here
17162 // uint64_t CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR arg);
17164 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(arg: bigint): bigint {
17165 if(!isWasmInitialized) {
17166 throw new Error("initializeWasm() must be awaited first!");
17168 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(arg);
17169 return nativeResponseValue;
17171 // struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR orig);
17173 export function CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(orig: bigint): bigint {
17174 if(!isWasmInitialized) {
17175 throw new Error("initializeWasm() must be awaited first!");
17177 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(orig);
17178 return nativeResponseValue;
17180 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_some(struct LDKOffersMessage o);
17182 export function COption_OffersMessageZ_some(o: bigint): bigint {
17183 if(!isWasmInitialized) {
17184 throw new Error("initializeWasm() must be awaited first!");
17186 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_some(o);
17187 return nativeResponseValue;
17189 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_none(void);
17191 export function COption_OffersMessageZ_none(): bigint {
17192 if(!isWasmInitialized) {
17193 throw new Error("initializeWasm() must be awaited first!");
17195 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_none();
17196 return nativeResponseValue;
17198 // void COption_OffersMessageZ_free(struct LDKCOption_OffersMessageZ _res);
17200 export function COption_OffersMessageZ_free(_res: bigint): void {
17201 if(!isWasmInitialized) {
17202 throw new Error("initializeWasm() must be awaited first!");
17204 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_free(_res);
17205 // debug statements here
17207 // uint64_t COption_OffersMessageZ_clone_ptr(LDKCOption_OffersMessageZ *NONNULL_PTR arg);
17209 export function COption_OffersMessageZ_clone_ptr(arg: bigint): bigint {
17210 if(!isWasmInitialized) {
17211 throw new Error("initializeWasm() must be awaited first!");
17213 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_clone_ptr(arg);
17214 return nativeResponseValue;
17216 // struct LDKCOption_OffersMessageZ COption_OffersMessageZ_clone(const struct LDKCOption_OffersMessageZ *NONNULL_PTR orig);
17218 export function COption_OffersMessageZ_clone(orig: bigint): bigint {
17219 if(!isWasmInitialized) {
17220 throw new Error("initializeWasm() must be awaited first!");
17222 const nativeResponseValue = wasm.TS_COption_OffersMessageZ_clone(orig);
17223 return nativeResponseValue;
17225 // uint64_t C3Tuple_OffersMessageDestinationBlindedPathZ_clone_ptr(LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR arg);
17227 export function C3Tuple_OffersMessageDestinationBlindedPathZ_clone_ptr(arg: bigint): bigint {
17228 if(!isWasmInitialized) {
17229 throw new Error("initializeWasm() must be awaited first!");
17231 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_clone_ptr(arg);
17232 return nativeResponseValue;
17234 // struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ C3Tuple_OffersMessageDestinationBlindedPathZ_clone(const struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ *NONNULL_PTR orig);
17236 export function C3Tuple_OffersMessageDestinationBlindedPathZ_clone(orig: bigint): bigint {
17237 if(!isWasmInitialized) {
17238 throw new Error("initializeWasm() must be awaited first!");
17240 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_clone(orig);
17241 return nativeResponseValue;
17243 // struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ C3Tuple_OffersMessageDestinationBlindedPathZ_new(struct LDKOffersMessage a, struct LDKDestination b, struct LDKBlindedPath c);
17245 export function C3Tuple_OffersMessageDestinationBlindedPathZ_new(a: bigint, b: bigint, c: bigint): bigint {
17246 if(!isWasmInitialized) {
17247 throw new Error("initializeWasm() must be awaited first!");
17249 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_new(a, b, c);
17250 return nativeResponseValue;
17252 // void C3Tuple_OffersMessageDestinationBlindedPathZ_free(struct LDKC3Tuple_OffersMessageDestinationBlindedPathZ _res);
17254 export function C3Tuple_OffersMessageDestinationBlindedPathZ_free(_res: bigint): void {
17255 if(!isWasmInitialized) {
17256 throw new Error("initializeWasm() must be awaited first!");
17258 const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_free(_res);
17259 // debug statements here
17261 // void CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(struct LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ _res);
17263 export function CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(_res: number): void {
17264 if(!isWasmInitialized) {
17265 throw new Error("initializeWasm() must be awaited first!");
17267 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(_res);
17268 // debug statements here
17270 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
17272 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
17273 if(!isWasmInitialized) {
17274 throw new Error("initializeWasm() must be awaited first!");
17276 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
17277 return nativeResponseValue;
17279 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
17281 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
17282 if(!isWasmInitialized) {
17283 throw new Error("initializeWasm() must be awaited first!");
17285 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
17286 return nativeResponseValue;
17288 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
17290 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
17291 if(!isWasmInitialized) {
17292 throw new Error("initializeWasm() must be awaited first!");
17294 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
17295 return nativeResponseValue;
17297 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
17299 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
17300 if(!isWasmInitialized) {
17301 throw new Error("initializeWasm() must be awaited first!");
17303 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
17304 // debug statements here
17306 // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
17308 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17309 if(!isWasmInitialized) {
17310 throw new Error("initializeWasm() must be awaited first!");
17312 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
17313 return nativeResponseValue;
17315 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
17317 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
17318 if(!isWasmInitialized) {
17319 throw new Error("initializeWasm() must be awaited first!");
17321 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
17322 return nativeResponseValue;
17324 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
17326 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
17327 if(!isWasmInitialized) {
17328 throw new Error("initializeWasm() must be awaited first!");
17330 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
17331 return nativeResponseValue;
17333 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
17335 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
17336 if(!isWasmInitialized) {
17337 throw new Error("initializeWasm() must be awaited first!");
17339 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
17340 return nativeResponseValue;
17342 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
17344 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
17345 if(!isWasmInitialized) {
17346 throw new Error("initializeWasm() must be awaited first!");
17348 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
17349 return nativeResponseValue;
17351 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
17353 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
17354 if(!isWasmInitialized) {
17355 throw new Error("initializeWasm() must be awaited first!");
17357 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
17358 // debug statements here
17360 // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
17362 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17363 if(!isWasmInitialized) {
17364 throw new Error("initializeWasm() must be awaited first!");
17366 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
17367 return nativeResponseValue;
17369 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
17371 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
17372 if(!isWasmInitialized) {
17373 throw new Error("initializeWasm() must be awaited first!");
17375 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
17376 return nativeResponseValue;
17378 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
17380 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
17381 if(!isWasmInitialized) {
17382 throw new Error("initializeWasm() must be awaited first!");
17384 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
17385 return nativeResponseValue;
17387 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
17389 export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
17390 if(!isWasmInitialized) {
17391 throw new Error("initializeWasm() must be awaited first!");
17393 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
17394 return nativeResponseValue;
17396 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
17398 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
17399 if(!isWasmInitialized) {
17400 throw new Error("initializeWasm() must be awaited first!");
17402 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
17403 return nativeResponseValue;
17405 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
17407 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
17408 if(!isWasmInitialized) {
17409 throw new Error("initializeWasm() must be awaited first!");
17411 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
17412 // debug statements here
17414 // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
17416 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17417 if(!isWasmInitialized) {
17418 throw new Error("initializeWasm() must be awaited first!");
17420 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
17421 return nativeResponseValue;
17423 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
17425 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
17426 if(!isWasmInitialized) {
17427 throw new Error("initializeWasm() must be awaited first!");
17429 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
17430 return nativeResponseValue;
17432 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
17434 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: bigint): bigint {
17435 if(!isWasmInitialized) {
17436 throw new Error("initializeWasm() must be awaited first!");
17438 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
17439 return nativeResponseValue;
17441 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
17443 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: bigint): bigint {
17444 if(!isWasmInitialized) {
17445 throw new Error("initializeWasm() must be awaited first!");
17447 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
17448 return nativeResponseValue;
17450 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
17452 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: bigint): boolean {
17453 if(!isWasmInitialized) {
17454 throw new Error("initializeWasm() must be awaited first!");
17456 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
17457 return nativeResponseValue;
17459 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
17461 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: bigint): void {
17462 if(!isWasmInitialized) {
17463 throw new Error("initializeWasm() must be awaited first!");
17465 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
17466 // debug statements here
17468 // uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
17470 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17471 if(!isWasmInitialized) {
17472 throw new Error("initializeWasm() must be awaited first!");
17474 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
17475 return nativeResponseValue;
17477 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
17479 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: bigint): bigint {
17480 if(!isWasmInitialized) {
17481 throw new Error("initializeWasm() must be awaited first!");
17483 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
17484 return nativeResponseValue;
17486 // struct LDKCResult_BlindedForwardDecodeErrorZ CResult_BlindedForwardDecodeErrorZ_ok(struct LDKBlindedForward o);
17488 export function CResult_BlindedForwardDecodeErrorZ_ok(o: bigint): bigint {
17489 if(!isWasmInitialized) {
17490 throw new Error("initializeWasm() must be awaited first!");
17492 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_ok(o);
17493 return nativeResponseValue;
17495 // struct LDKCResult_BlindedForwardDecodeErrorZ CResult_BlindedForwardDecodeErrorZ_err(struct LDKDecodeError e);
17497 export function CResult_BlindedForwardDecodeErrorZ_err(e: bigint): bigint {
17498 if(!isWasmInitialized) {
17499 throw new Error("initializeWasm() must be awaited first!");
17501 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_err(e);
17502 return nativeResponseValue;
17504 // bool CResult_BlindedForwardDecodeErrorZ_is_ok(const struct LDKCResult_BlindedForwardDecodeErrorZ *NONNULL_PTR o);
17506 export function CResult_BlindedForwardDecodeErrorZ_is_ok(o: bigint): boolean {
17507 if(!isWasmInitialized) {
17508 throw new Error("initializeWasm() must be awaited first!");
17510 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_is_ok(o);
17511 return nativeResponseValue;
17513 // void CResult_BlindedForwardDecodeErrorZ_free(struct LDKCResult_BlindedForwardDecodeErrorZ _res);
17515 export function CResult_BlindedForwardDecodeErrorZ_free(_res: bigint): void {
17516 if(!isWasmInitialized) {
17517 throw new Error("initializeWasm() must be awaited first!");
17519 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_free(_res);
17520 // debug statements here
17522 // uint64_t CResult_BlindedForwardDecodeErrorZ_clone_ptr(LDKCResult_BlindedForwardDecodeErrorZ *NONNULL_PTR arg);
17524 export function CResult_BlindedForwardDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17525 if(!isWasmInitialized) {
17526 throw new Error("initializeWasm() must be awaited first!");
17528 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_clone_ptr(arg);
17529 return nativeResponseValue;
17531 // struct LDKCResult_BlindedForwardDecodeErrorZ CResult_BlindedForwardDecodeErrorZ_clone(const struct LDKCResult_BlindedForwardDecodeErrorZ *NONNULL_PTR orig);
17533 export function CResult_BlindedForwardDecodeErrorZ_clone(orig: bigint): bigint {
17534 if(!isWasmInitialized) {
17535 throw new Error("initializeWasm() must be awaited first!");
17537 const nativeResponseValue = wasm.TS_CResult_BlindedForwardDecodeErrorZ_clone(orig);
17538 return nativeResponseValue;
17540 // struct LDKCResult_PendingHTLCRoutingDecodeErrorZ CResult_PendingHTLCRoutingDecodeErrorZ_ok(struct LDKPendingHTLCRouting o);
17542 export function CResult_PendingHTLCRoutingDecodeErrorZ_ok(o: bigint): bigint {
17543 if(!isWasmInitialized) {
17544 throw new Error("initializeWasm() must be awaited first!");
17546 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_ok(o);
17547 return nativeResponseValue;
17549 // struct LDKCResult_PendingHTLCRoutingDecodeErrorZ CResult_PendingHTLCRoutingDecodeErrorZ_err(struct LDKDecodeError e);
17551 export function CResult_PendingHTLCRoutingDecodeErrorZ_err(e: bigint): bigint {
17552 if(!isWasmInitialized) {
17553 throw new Error("initializeWasm() must be awaited first!");
17555 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_err(e);
17556 return nativeResponseValue;
17558 // bool CResult_PendingHTLCRoutingDecodeErrorZ_is_ok(const struct LDKCResult_PendingHTLCRoutingDecodeErrorZ *NONNULL_PTR o);
17560 export function CResult_PendingHTLCRoutingDecodeErrorZ_is_ok(o: bigint): boolean {
17561 if(!isWasmInitialized) {
17562 throw new Error("initializeWasm() must be awaited first!");
17564 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_is_ok(o);
17565 return nativeResponseValue;
17567 // void CResult_PendingHTLCRoutingDecodeErrorZ_free(struct LDKCResult_PendingHTLCRoutingDecodeErrorZ _res);
17569 export function CResult_PendingHTLCRoutingDecodeErrorZ_free(_res: bigint): void {
17570 if(!isWasmInitialized) {
17571 throw new Error("initializeWasm() must be awaited first!");
17573 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_free(_res);
17574 // debug statements here
17576 // uint64_t CResult_PendingHTLCRoutingDecodeErrorZ_clone_ptr(LDKCResult_PendingHTLCRoutingDecodeErrorZ *NONNULL_PTR arg);
17578 export function CResult_PendingHTLCRoutingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17579 if(!isWasmInitialized) {
17580 throw new Error("initializeWasm() must be awaited first!");
17582 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_clone_ptr(arg);
17583 return nativeResponseValue;
17585 // struct LDKCResult_PendingHTLCRoutingDecodeErrorZ CResult_PendingHTLCRoutingDecodeErrorZ_clone(const struct LDKCResult_PendingHTLCRoutingDecodeErrorZ *NONNULL_PTR orig);
17587 export function CResult_PendingHTLCRoutingDecodeErrorZ_clone(orig: bigint): bigint {
17588 if(!isWasmInitialized) {
17589 throw new Error("initializeWasm() must be awaited first!");
17591 const nativeResponseValue = wasm.TS_CResult_PendingHTLCRoutingDecodeErrorZ_clone(orig);
17592 return nativeResponseValue;
17594 // struct LDKCResult_PendingHTLCInfoDecodeErrorZ CResult_PendingHTLCInfoDecodeErrorZ_ok(struct LDKPendingHTLCInfo o);
17596 export function CResult_PendingHTLCInfoDecodeErrorZ_ok(o: bigint): bigint {
17597 if(!isWasmInitialized) {
17598 throw new Error("initializeWasm() must be awaited first!");
17600 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_ok(o);
17601 return nativeResponseValue;
17603 // struct LDKCResult_PendingHTLCInfoDecodeErrorZ CResult_PendingHTLCInfoDecodeErrorZ_err(struct LDKDecodeError e);
17605 export function CResult_PendingHTLCInfoDecodeErrorZ_err(e: bigint): bigint {
17606 if(!isWasmInitialized) {
17607 throw new Error("initializeWasm() must be awaited first!");
17609 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_err(e);
17610 return nativeResponseValue;
17612 // bool CResult_PendingHTLCInfoDecodeErrorZ_is_ok(const struct LDKCResult_PendingHTLCInfoDecodeErrorZ *NONNULL_PTR o);
17614 export function CResult_PendingHTLCInfoDecodeErrorZ_is_ok(o: bigint): boolean {
17615 if(!isWasmInitialized) {
17616 throw new Error("initializeWasm() must be awaited first!");
17618 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_is_ok(o);
17619 return nativeResponseValue;
17621 // void CResult_PendingHTLCInfoDecodeErrorZ_free(struct LDKCResult_PendingHTLCInfoDecodeErrorZ _res);
17623 export function CResult_PendingHTLCInfoDecodeErrorZ_free(_res: bigint): void {
17624 if(!isWasmInitialized) {
17625 throw new Error("initializeWasm() must be awaited first!");
17627 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_free(_res);
17628 // debug statements here
17630 // uint64_t CResult_PendingHTLCInfoDecodeErrorZ_clone_ptr(LDKCResult_PendingHTLCInfoDecodeErrorZ *NONNULL_PTR arg);
17632 export function CResult_PendingHTLCInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17633 if(!isWasmInitialized) {
17634 throw new Error("initializeWasm() must be awaited first!");
17636 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_clone_ptr(arg);
17637 return nativeResponseValue;
17639 // struct LDKCResult_PendingHTLCInfoDecodeErrorZ CResult_PendingHTLCInfoDecodeErrorZ_clone(const struct LDKCResult_PendingHTLCInfoDecodeErrorZ *NONNULL_PTR orig);
17641 export function CResult_PendingHTLCInfoDecodeErrorZ_clone(orig: bigint): bigint {
17642 if(!isWasmInitialized) {
17643 throw new Error("initializeWasm() must be awaited first!");
17645 const nativeResponseValue = wasm.TS_CResult_PendingHTLCInfoDecodeErrorZ_clone(orig);
17646 return nativeResponseValue;
17648 // struct LDKCResult_BlindedFailureDecodeErrorZ CResult_BlindedFailureDecodeErrorZ_ok(enum LDKBlindedFailure o);
17650 export function CResult_BlindedFailureDecodeErrorZ_ok(o: BlindedFailure): bigint {
17651 if(!isWasmInitialized) {
17652 throw new Error("initializeWasm() must be awaited first!");
17654 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_ok(o);
17655 return nativeResponseValue;
17657 // struct LDKCResult_BlindedFailureDecodeErrorZ CResult_BlindedFailureDecodeErrorZ_err(struct LDKDecodeError e);
17659 export function CResult_BlindedFailureDecodeErrorZ_err(e: bigint): bigint {
17660 if(!isWasmInitialized) {
17661 throw new Error("initializeWasm() must be awaited first!");
17663 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_err(e);
17664 return nativeResponseValue;
17666 // bool CResult_BlindedFailureDecodeErrorZ_is_ok(const struct LDKCResult_BlindedFailureDecodeErrorZ *NONNULL_PTR o);
17668 export function CResult_BlindedFailureDecodeErrorZ_is_ok(o: bigint): boolean {
17669 if(!isWasmInitialized) {
17670 throw new Error("initializeWasm() must be awaited first!");
17672 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_is_ok(o);
17673 return nativeResponseValue;
17675 // void CResult_BlindedFailureDecodeErrorZ_free(struct LDKCResult_BlindedFailureDecodeErrorZ _res);
17677 export function CResult_BlindedFailureDecodeErrorZ_free(_res: bigint): void {
17678 if(!isWasmInitialized) {
17679 throw new Error("initializeWasm() must be awaited first!");
17681 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_free(_res);
17682 // debug statements here
17684 // uint64_t CResult_BlindedFailureDecodeErrorZ_clone_ptr(LDKCResult_BlindedFailureDecodeErrorZ *NONNULL_PTR arg);
17686 export function CResult_BlindedFailureDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17687 if(!isWasmInitialized) {
17688 throw new Error("initializeWasm() must be awaited first!");
17690 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_clone_ptr(arg);
17691 return nativeResponseValue;
17693 // struct LDKCResult_BlindedFailureDecodeErrorZ CResult_BlindedFailureDecodeErrorZ_clone(const struct LDKCResult_BlindedFailureDecodeErrorZ *NONNULL_PTR orig);
17695 export function CResult_BlindedFailureDecodeErrorZ_clone(orig: bigint): bigint {
17696 if(!isWasmInitialized) {
17697 throw new Error("initializeWasm() must be awaited first!");
17699 const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_clone(orig);
17700 return nativeResponseValue;
17702 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_ok(enum LDKChannelShutdownState o);
17704 export function CResult_ChannelShutdownStateDecodeErrorZ_ok(o: ChannelShutdownState): bigint {
17705 if(!isWasmInitialized) {
17706 throw new Error("initializeWasm() must be awaited first!");
17708 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_ok(o);
17709 return nativeResponseValue;
17711 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_err(struct LDKDecodeError e);
17713 export function CResult_ChannelShutdownStateDecodeErrorZ_err(e: bigint): bigint {
17714 if(!isWasmInitialized) {
17715 throw new Error("initializeWasm() must be awaited first!");
17717 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_err(e);
17718 return nativeResponseValue;
17720 // bool CResult_ChannelShutdownStateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR o);
17722 export function CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o: bigint): boolean {
17723 if(!isWasmInitialized) {
17724 throw new Error("initializeWasm() must be awaited first!");
17726 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o);
17727 return nativeResponseValue;
17729 // void CResult_ChannelShutdownStateDecodeErrorZ_free(struct LDKCResult_ChannelShutdownStateDecodeErrorZ _res);
17731 export function CResult_ChannelShutdownStateDecodeErrorZ_free(_res: bigint): void {
17732 if(!isWasmInitialized) {
17733 throw new Error("initializeWasm() must be awaited first!");
17735 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_free(_res);
17736 // debug statements here
17738 // uint64_t CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR arg);
17740 export function CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17741 if(!isWasmInitialized) {
17742 throw new Error("initializeWasm() must be awaited first!");
17744 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg);
17745 return nativeResponseValue;
17747 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_clone(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR orig);
17749 export function CResult_ChannelShutdownStateDecodeErrorZ_clone(orig: bigint): bigint {
17750 if(!isWasmInitialized) {
17751 throw new Error("initializeWasm() must be awaited first!");
17753 const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone(orig);
17754 return nativeResponseValue;
17756 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
17758 export function CVec_ChannelMonitorZ_free(_res: number): void {
17759 if(!isWasmInitialized) {
17760 throw new Error("initializeWasm() must be awaited first!");
17762 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
17763 // debug statements here
17765 // struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ C2Tuple_ThirtyTwoBytesChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
17767 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_new(a: number, b: bigint): bigint {
17768 if(!isWasmInitialized) {
17769 throw new Error("initializeWasm() must be awaited first!");
17771 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_new(a, b);
17772 return nativeResponseValue;
17774 // void C2Tuple_ThirtyTwoBytesChannelManagerZ_free(struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ _res);
17776 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_free(_res: bigint): void {
17777 if(!isWasmInitialized) {
17778 throw new Error("initializeWasm() must be awaited first!");
17780 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_free(_res);
17781 // debug statements here
17783 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ o);
17785 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(o: bigint): bigint {
17786 if(!isWasmInitialized) {
17787 throw new Error("initializeWasm() must be awaited first!");
17789 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(o);
17790 return nativeResponseValue;
17792 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
17794 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(e: bigint): bigint {
17795 if(!isWasmInitialized) {
17796 throw new Error("initializeWasm() must be awaited first!");
17798 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(e);
17799 return nativeResponseValue;
17801 // bool CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR o);
17803 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(o: bigint): boolean {
17804 if(!isWasmInitialized) {
17805 throw new Error("initializeWasm() must be awaited first!");
17807 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(o);
17808 return nativeResponseValue;
17810 // void CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ _res);
17812 export function CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(_res: bigint): void {
17813 if(!isWasmInitialized) {
17814 throw new Error("initializeWasm() must be awaited first!");
17816 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(_res);
17817 // debug statements here
17819 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_ok(struct LDKMaxDustHTLCExposure o);
17821 export function CResult_MaxDustHTLCExposureDecodeErrorZ_ok(o: bigint): bigint {
17822 if(!isWasmInitialized) {
17823 throw new Error("initializeWasm() must be awaited first!");
17825 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_ok(o);
17826 return nativeResponseValue;
17828 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_err(struct LDKDecodeError e);
17830 export function CResult_MaxDustHTLCExposureDecodeErrorZ_err(e: bigint): bigint {
17831 if(!isWasmInitialized) {
17832 throw new Error("initializeWasm() must be awaited first!");
17834 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_err(e);
17835 return nativeResponseValue;
17837 // bool CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(const struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR o);
17839 export function CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(o: bigint): boolean {
17840 if(!isWasmInitialized) {
17841 throw new Error("initializeWasm() must be awaited first!");
17843 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(o);
17844 return nativeResponseValue;
17846 // void CResult_MaxDustHTLCExposureDecodeErrorZ_free(struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ _res);
17848 export function CResult_MaxDustHTLCExposureDecodeErrorZ_free(_res: bigint): void {
17849 if(!isWasmInitialized) {
17850 throw new Error("initializeWasm() must be awaited first!");
17852 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_free(_res);
17853 // debug statements here
17855 // uint64_t CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR arg);
17857 export function CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17858 if(!isWasmInitialized) {
17859 throw new Error("initializeWasm() must be awaited first!");
17861 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(arg);
17862 return nativeResponseValue;
17864 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ CResult_MaxDustHTLCExposureDecodeErrorZ_clone(const struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR orig);
17866 export function CResult_MaxDustHTLCExposureDecodeErrorZ_clone(orig: bigint): bigint {
17867 if(!isWasmInitialized) {
17868 throw new Error("initializeWasm() must be awaited first!");
17870 const nativeResponseValue = wasm.TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone(orig);
17871 return nativeResponseValue;
17873 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
17875 export function CResult_ChannelConfigDecodeErrorZ_ok(o: bigint): bigint {
17876 if(!isWasmInitialized) {
17877 throw new Error("initializeWasm() must be awaited first!");
17879 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
17880 return nativeResponseValue;
17882 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
17884 export function CResult_ChannelConfigDecodeErrorZ_err(e: bigint): bigint {
17885 if(!isWasmInitialized) {
17886 throw new Error("initializeWasm() must be awaited first!");
17888 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
17889 return nativeResponseValue;
17891 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
17893 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: bigint): boolean {
17894 if(!isWasmInitialized) {
17895 throw new Error("initializeWasm() must be awaited first!");
17897 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
17898 return nativeResponseValue;
17900 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
17902 export function CResult_ChannelConfigDecodeErrorZ_free(_res: bigint): void {
17903 if(!isWasmInitialized) {
17904 throw new Error("initializeWasm() must be awaited first!");
17906 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
17907 // debug statements here
17909 // uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
17911 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: bigint): bigint {
17912 if(!isWasmInitialized) {
17913 throw new Error("initializeWasm() must be awaited first!");
17915 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
17916 return nativeResponseValue;
17918 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
17920 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: bigint): bigint {
17921 if(!isWasmInitialized) {
17922 throw new Error("initializeWasm() must be awaited first!");
17924 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
17925 return nativeResponseValue;
17927 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_some(struct LDKMaxDustHTLCExposure o);
17929 export function COption_MaxDustHTLCExposureZ_some(o: bigint): bigint {
17930 if(!isWasmInitialized) {
17931 throw new Error("initializeWasm() must be awaited first!");
17933 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_some(o);
17934 return nativeResponseValue;
17936 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_none(void);
17938 export function COption_MaxDustHTLCExposureZ_none(): bigint {
17939 if(!isWasmInitialized) {
17940 throw new Error("initializeWasm() must be awaited first!");
17942 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_none();
17943 return nativeResponseValue;
17945 // void COption_MaxDustHTLCExposureZ_free(struct LDKCOption_MaxDustHTLCExposureZ _res);
17947 export function COption_MaxDustHTLCExposureZ_free(_res: bigint): void {
17948 if(!isWasmInitialized) {
17949 throw new Error("initializeWasm() must be awaited first!");
17951 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_free(_res);
17952 // debug statements here
17954 // uint64_t COption_MaxDustHTLCExposureZ_clone_ptr(LDKCOption_MaxDustHTLCExposureZ *NONNULL_PTR arg);
17956 export function COption_MaxDustHTLCExposureZ_clone_ptr(arg: bigint): bigint {
17957 if(!isWasmInitialized) {
17958 throw new Error("initializeWasm() must be awaited first!");
17960 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_clone_ptr(arg);
17961 return nativeResponseValue;
17963 // struct LDKCOption_MaxDustHTLCExposureZ COption_MaxDustHTLCExposureZ_clone(const struct LDKCOption_MaxDustHTLCExposureZ *NONNULL_PTR orig);
17965 export function COption_MaxDustHTLCExposureZ_clone(orig: bigint): bigint {
17966 if(!isWasmInitialized) {
17967 throw new Error("initializeWasm() must be awaited first!");
17969 const nativeResponseValue = wasm.TS_COption_MaxDustHTLCExposureZ_clone(orig);
17970 return nativeResponseValue;
17972 // struct LDKCOption_APIErrorZ COption_APIErrorZ_some(struct LDKAPIError o);
17974 export function COption_APIErrorZ_some(o: bigint): bigint {
17975 if(!isWasmInitialized) {
17976 throw new Error("initializeWasm() must be awaited first!");
17978 const nativeResponseValue = wasm.TS_COption_APIErrorZ_some(o);
17979 return nativeResponseValue;
17981 // struct LDKCOption_APIErrorZ COption_APIErrorZ_none(void);
17983 export function COption_APIErrorZ_none(): bigint {
17984 if(!isWasmInitialized) {
17985 throw new Error("initializeWasm() must be awaited first!");
17987 const nativeResponseValue = wasm.TS_COption_APIErrorZ_none();
17988 return nativeResponseValue;
17990 // void COption_APIErrorZ_free(struct LDKCOption_APIErrorZ _res);
17992 export function COption_APIErrorZ_free(_res: bigint): void {
17993 if(!isWasmInitialized) {
17994 throw new Error("initializeWasm() must be awaited first!");
17996 const nativeResponseValue = wasm.TS_COption_APIErrorZ_free(_res);
17997 // debug statements here
17999 // uint64_t COption_APIErrorZ_clone_ptr(LDKCOption_APIErrorZ *NONNULL_PTR arg);
18001 export function COption_APIErrorZ_clone_ptr(arg: bigint): bigint {
18002 if(!isWasmInitialized) {
18003 throw new Error("initializeWasm() must be awaited first!");
18005 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone_ptr(arg);
18006 return nativeResponseValue;
18008 // struct LDKCOption_APIErrorZ COption_APIErrorZ_clone(const struct LDKCOption_APIErrorZ *NONNULL_PTR orig);
18010 export function COption_APIErrorZ_clone(orig: bigint): bigint {
18011 if(!isWasmInitialized) {
18012 throw new Error("initializeWasm() must be awaited first!");
18014 const nativeResponseValue = wasm.TS_COption_APIErrorZ_clone(orig);
18015 return nativeResponseValue;
18017 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_ok(struct LDKCOption_APIErrorZ o);
18019 export function CResult_COption_APIErrorZDecodeErrorZ_ok(o: bigint): bigint {
18020 if(!isWasmInitialized) {
18021 throw new Error("initializeWasm() must be awaited first!");
18023 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_ok(o);
18024 return nativeResponseValue;
18026 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_err(struct LDKDecodeError e);
18028 export function CResult_COption_APIErrorZDecodeErrorZ_err(e: bigint): bigint {
18029 if(!isWasmInitialized) {
18030 throw new Error("initializeWasm() must be awaited first!");
18032 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_err(e);
18033 return nativeResponseValue;
18035 // bool CResult_COption_APIErrorZDecodeErrorZ_is_ok(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR o);
18037 export function CResult_COption_APIErrorZDecodeErrorZ_is_ok(o: bigint): boolean {
18038 if(!isWasmInitialized) {
18039 throw new Error("initializeWasm() must be awaited first!");
18041 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok(o);
18042 return nativeResponseValue;
18044 // void CResult_COption_APIErrorZDecodeErrorZ_free(struct LDKCResult_COption_APIErrorZDecodeErrorZ _res);
18046 export function CResult_COption_APIErrorZDecodeErrorZ_free(_res: bigint): void {
18047 if(!isWasmInitialized) {
18048 throw new Error("initializeWasm() must be awaited first!");
18050 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_free(_res);
18051 // debug statements here
18053 // uint64_t CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR arg);
18055 export function CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18056 if(!isWasmInitialized) {
18057 throw new Error("initializeWasm() must be awaited first!");
18059 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg);
18060 return nativeResponseValue;
18062 // struct LDKCResult_COption_APIErrorZDecodeErrorZ CResult_COption_APIErrorZDecodeErrorZ_clone(const struct LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR orig);
18064 export function CResult_COption_APIErrorZDecodeErrorZ_clone(orig: bigint): bigint {
18065 if(!isWasmInitialized) {
18066 throw new Error("initializeWasm() must be awaited first!");
18068 const nativeResponseValue = wasm.TS_CResult_COption_APIErrorZDecodeErrorZ_clone(orig);
18069 return nativeResponseValue;
18071 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
18073 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: bigint): bigint {
18074 if(!isWasmInitialized) {
18075 throw new Error("initializeWasm() must be awaited first!");
18077 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
18078 return nativeResponseValue;
18080 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
18082 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: bigint): bigint {
18083 if(!isWasmInitialized) {
18084 throw new Error("initializeWasm() must be awaited first!");
18086 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
18087 return nativeResponseValue;
18089 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
18091 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
18092 if(!isWasmInitialized) {
18093 throw new Error("initializeWasm() must be awaited first!");
18095 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
18096 return nativeResponseValue;
18098 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
18100 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: bigint): void {
18101 if(!isWasmInitialized) {
18102 throw new Error("initializeWasm() must be awaited first!");
18104 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
18105 // debug statements here
18107 // uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
18109 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18110 if(!isWasmInitialized) {
18111 throw new Error("initializeWasm() must be awaited first!");
18113 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
18114 return nativeResponseValue;
18116 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
18118 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: bigint): bigint {
18119 if(!isWasmInitialized) {
18120 throw new Error("initializeWasm() must be awaited first!");
18122 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
18123 return nativeResponseValue;
18125 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
18127 export function COption_MonitorEventZ_some(o: bigint): bigint {
18128 if(!isWasmInitialized) {
18129 throw new Error("initializeWasm() must be awaited first!");
18131 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
18132 return nativeResponseValue;
18134 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
18136 export function COption_MonitorEventZ_none(): bigint {
18137 if(!isWasmInitialized) {
18138 throw new Error("initializeWasm() must be awaited first!");
18140 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
18141 return nativeResponseValue;
18143 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
18145 export function COption_MonitorEventZ_free(_res: bigint): void {
18146 if(!isWasmInitialized) {
18147 throw new Error("initializeWasm() must be awaited first!");
18149 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
18150 // debug statements here
18152 // uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
18154 export function COption_MonitorEventZ_clone_ptr(arg: bigint): bigint {
18155 if(!isWasmInitialized) {
18156 throw new Error("initializeWasm() must be awaited first!");
18158 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
18159 return nativeResponseValue;
18161 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
18163 export function COption_MonitorEventZ_clone(orig: bigint): bigint {
18164 if(!isWasmInitialized) {
18165 throw new Error("initializeWasm() must be awaited first!");
18167 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
18168 return nativeResponseValue;
18170 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
18172 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: bigint): bigint {
18173 if(!isWasmInitialized) {
18174 throw new Error("initializeWasm() must be awaited first!");
18176 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
18177 return nativeResponseValue;
18179 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
18181 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: bigint): bigint {
18182 if(!isWasmInitialized) {
18183 throw new Error("initializeWasm() must be awaited first!");
18185 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
18186 return nativeResponseValue;
18188 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
18190 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: bigint): boolean {
18191 if(!isWasmInitialized) {
18192 throw new Error("initializeWasm() must be awaited first!");
18194 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
18195 return nativeResponseValue;
18197 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
18199 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: bigint): void {
18200 if(!isWasmInitialized) {
18201 throw new Error("initializeWasm() must be awaited first!");
18203 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
18204 // debug statements here
18206 // uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
18208 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18209 if(!isWasmInitialized) {
18210 throw new Error("initializeWasm() must be awaited first!");
18212 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
18213 return nativeResponseValue;
18215 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
18217 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: bigint): bigint {
18218 if(!isWasmInitialized) {
18219 throw new Error("initializeWasm() must be awaited first!");
18221 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
18222 return nativeResponseValue;
18224 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
18226 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: bigint): bigint {
18227 if(!isWasmInitialized) {
18228 throw new Error("initializeWasm() must be awaited first!");
18230 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
18231 return nativeResponseValue;
18233 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
18235 export function CResult_HTLCUpdateDecodeErrorZ_err(e: bigint): bigint {
18236 if(!isWasmInitialized) {
18237 throw new Error("initializeWasm() must be awaited first!");
18239 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
18240 return nativeResponseValue;
18242 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
18244 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
18245 if(!isWasmInitialized) {
18246 throw new Error("initializeWasm() must be awaited first!");
18248 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
18249 return nativeResponseValue;
18251 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
18253 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: bigint): void {
18254 if(!isWasmInitialized) {
18255 throw new Error("initializeWasm() must be awaited first!");
18257 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
18258 // debug statements here
18260 // uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
18262 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18263 if(!isWasmInitialized) {
18264 throw new Error("initializeWasm() must be awaited first!");
18266 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
18267 return nativeResponseValue;
18269 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
18271 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: bigint): bigint {
18272 if(!isWasmInitialized) {
18273 throw new Error("initializeWasm() must be awaited first!");
18275 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
18276 return nativeResponseValue;
18278 // uint64_t C2Tuple_OutPointCVec_u8ZZ_clone_ptr(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR arg);
18280 export function C2Tuple_OutPointCVec_u8ZZ_clone_ptr(arg: bigint): bigint {
18281 if(!isWasmInitialized) {
18282 throw new Error("initializeWasm() must be awaited first!");
18284 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_clone_ptr(arg);
18285 return nativeResponseValue;
18287 // struct LDKC2Tuple_OutPointCVec_u8ZZ C2Tuple_OutPointCVec_u8ZZ_clone(const struct LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR orig);
18289 export function C2Tuple_OutPointCVec_u8ZZ_clone(orig: bigint): bigint {
18290 if(!isWasmInitialized) {
18291 throw new Error("initializeWasm() must be awaited first!");
18293 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_clone(orig);
18294 return nativeResponseValue;
18296 // struct LDKC2Tuple_OutPointCVec_u8ZZ C2Tuple_OutPointCVec_u8ZZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
18298 export function C2Tuple_OutPointCVec_u8ZZ_new(a: bigint, b: number): bigint {
18299 if(!isWasmInitialized) {
18300 throw new Error("initializeWasm() must be awaited first!");
18302 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_new(a, b);
18303 return nativeResponseValue;
18305 // void C2Tuple_OutPointCVec_u8ZZ_free(struct LDKC2Tuple_OutPointCVec_u8ZZ _res);
18307 export function C2Tuple_OutPointCVec_u8ZZ_free(_res: bigint): void {
18308 if(!isWasmInitialized) {
18309 throw new Error("initializeWasm() must be awaited first!");
18311 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_u8ZZ_free(_res);
18312 // debug statements here
18314 // uint64_t C2Tuple_u32CVec_u8ZZ_clone_ptr(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR arg);
18316 export function C2Tuple_u32CVec_u8ZZ_clone_ptr(arg: bigint): bigint {
18317 if(!isWasmInitialized) {
18318 throw new Error("initializeWasm() must be awaited first!");
18320 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_clone_ptr(arg);
18321 return nativeResponseValue;
18323 // struct LDKC2Tuple_u32CVec_u8ZZ C2Tuple_u32CVec_u8ZZ_clone(const struct LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR orig);
18325 export function C2Tuple_u32CVec_u8ZZ_clone(orig: bigint): bigint {
18326 if(!isWasmInitialized) {
18327 throw new Error("initializeWasm() must be awaited first!");
18329 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_clone(orig);
18330 return nativeResponseValue;
18332 // struct LDKC2Tuple_u32CVec_u8ZZ C2Tuple_u32CVec_u8ZZ_new(uint32_t a, struct LDKCVec_u8Z b);
18334 export function C2Tuple_u32CVec_u8ZZ_new(a: number, b: number): bigint {
18335 if(!isWasmInitialized) {
18336 throw new Error("initializeWasm() must be awaited first!");
18338 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_new(a, b);
18339 return nativeResponseValue;
18341 // void C2Tuple_u32CVec_u8ZZ_free(struct LDKC2Tuple_u32CVec_u8ZZ _res);
18343 export function C2Tuple_u32CVec_u8ZZ_free(_res: bigint): void {
18344 if(!isWasmInitialized) {
18345 throw new Error("initializeWasm() must be awaited first!");
18347 const nativeResponseValue = wasm.TS_C2Tuple_u32CVec_u8ZZ_free(_res);
18348 // debug statements here
18350 // void CVec_C2Tuple_u32CVec_u8ZZZ_free(struct LDKCVec_C2Tuple_u32CVec_u8ZZZ _res);
18352 export function CVec_C2Tuple_u32CVec_u8ZZZ_free(_res: number): void {
18353 if(!isWasmInitialized) {
18354 throw new Error("initializeWasm() must be awaited first!");
18356 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32CVec_u8ZZZ_free(_res);
18357 // debug statements here
18359 // uint64_t C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR arg);
18361 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(arg: bigint): bigint {
18362 if(!isWasmInitialized) {
18363 throw new Error("initializeWasm() must be awaited first!");
18365 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(arg);
18366 return nativeResponseValue;
18368 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR orig);
18370 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(orig: bigint): bigint {
18371 if(!isWasmInitialized) {
18372 throw new Error("initializeWasm() must be awaited first!");
18374 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(orig);
18375 return nativeResponseValue;
18377 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32CVec_u8ZZZ b);
18379 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(a: number, b: number): bigint {
18380 if(!isWasmInitialized) {
18381 throw new Error("initializeWasm() must be awaited first!");
18383 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(a, b);
18384 return nativeResponseValue;
18386 // void C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ _res);
18388 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(_res: bigint): void {
18389 if(!isWasmInitialized) {
18390 throw new Error("initializeWasm() must be awaited first!");
18392 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(_res);
18393 // debug statements here
18395 // void CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ _res);
18397 export function CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(_res: number): void {
18398 if(!isWasmInitialized) {
18399 throw new Error("initializeWasm() must be awaited first!");
18401 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(_res);
18402 // debug statements here
18404 // void CVec_CommitmentTransactionZ_free(struct LDKCVec_CommitmentTransactionZ _res);
18406 export function CVec_CommitmentTransactionZ_free(_res: number): void {
18407 if(!isWasmInitialized) {
18408 throw new Error("initializeWasm() must be awaited first!");
18410 const nativeResponseValue = wasm.TS_CVec_CommitmentTransactionZ_free(_res);
18411 // debug statements here
18413 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
18415 export function CVec_TransactionZ_free(_res: number): void {
18416 if(!isWasmInitialized) {
18417 throw new Error("initializeWasm() must be awaited first!");
18419 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
18420 // debug statements here
18422 // uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
18424 export function C2Tuple_u32TxOutZ_clone_ptr(arg: bigint): bigint {
18425 if(!isWasmInitialized) {
18426 throw new Error("initializeWasm() must be awaited first!");
18428 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
18429 return nativeResponseValue;
18431 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
18433 export function C2Tuple_u32TxOutZ_clone(orig: bigint): bigint {
18434 if(!isWasmInitialized) {
18435 throw new Error("initializeWasm() must be awaited first!");
18437 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
18438 return nativeResponseValue;
18440 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
18442 export function C2Tuple_u32TxOutZ_new(a: number, b: bigint): bigint {
18443 if(!isWasmInitialized) {
18444 throw new Error("initializeWasm() must be awaited first!");
18446 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
18447 return nativeResponseValue;
18449 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
18451 export function C2Tuple_u32TxOutZ_free(_res: bigint): void {
18452 if(!isWasmInitialized) {
18453 throw new Error("initializeWasm() must be awaited first!");
18455 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
18456 // debug statements here
18458 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
18460 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
18461 if(!isWasmInitialized) {
18462 throw new Error("initializeWasm() must be awaited first!");
18464 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
18465 // debug statements here
18467 // uint64_t C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
18469 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: bigint): bigint {
18470 if(!isWasmInitialized) {
18471 throw new Error("initializeWasm() must be awaited first!");
18473 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
18474 return nativeResponseValue;
18476 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
18478 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(orig: bigint): bigint {
18479 if(!isWasmInitialized) {
18480 throw new Error("initializeWasm() must be awaited first!");
18482 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(orig);
18483 return nativeResponseValue;
18485 // struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
18487 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): bigint {
18488 if(!isWasmInitialized) {
18489 throw new Error("initializeWasm() must be awaited first!");
18491 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(a, b);
18492 return nativeResponseValue;
18494 // void C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ _res);
18496 export function C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(_res: bigint): void {
18497 if(!isWasmInitialized) {
18498 throw new Error("initializeWasm() must be awaited first!");
18500 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(_res);
18501 // debug statements here
18503 // void CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ _res);
18505 export function CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
18506 if(!isWasmInitialized) {
18507 throw new Error("initializeWasm() must be awaited first!");
18509 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(_res);
18510 // debug statements here
18512 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
18514 export function CVec_BalanceZ_free(_res: number): void {
18515 if(!isWasmInitialized) {
18516 throw new Error("initializeWasm() must be awaited first!");
18518 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
18519 // debug statements here
18521 // uint64_t C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR arg);
18523 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(arg: bigint): bigint {
18524 if(!isWasmInitialized) {
18525 throw new Error("initializeWasm() must be awaited first!");
18527 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(arg);
18528 return nativeResponseValue;
18530 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(const struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR orig);
18532 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(orig: bigint): bigint {
18533 if(!isWasmInitialized) {
18534 throw new Error("initializeWasm() must be awaited first!");
18536 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(orig);
18537 return nativeResponseValue;
18539 // struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
18541 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(a: number, b: bigint): bigint {
18542 if(!isWasmInitialized) {
18543 throw new Error("initializeWasm() must be awaited first!");
18545 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(a, b);
18546 return nativeResponseValue;
18548 // void C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ _res);
18550 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(_res: bigint): void {
18551 if(!isWasmInitialized) {
18552 throw new Error("initializeWasm() must be awaited first!");
18554 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(_res);
18555 // debug statements here
18557 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ o);
18559 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(o: bigint): bigint {
18560 if(!isWasmInitialized) {
18561 throw new Error("initializeWasm() must be awaited first!");
18563 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(o);
18564 return nativeResponseValue;
18566 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
18568 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(e: bigint): bigint {
18569 if(!isWasmInitialized) {
18570 throw new Error("initializeWasm() must be awaited first!");
18572 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(e);
18573 return nativeResponseValue;
18575 // bool CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
18577 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(o: bigint): boolean {
18578 if(!isWasmInitialized) {
18579 throw new Error("initializeWasm() must be awaited first!");
18581 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(o);
18582 return nativeResponseValue;
18584 // void CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ _res);
18586 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(_res: bigint): void {
18587 if(!isWasmInitialized) {
18588 throw new Error("initializeWasm() must be awaited first!");
18590 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(_res);
18591 // debug statements here
18593 // uint64_t CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
18595 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18596 if(!isWasmInitialized) {
18597 throw new Error("initializeWasm() must be awaited first!");
18599 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(arg);
18600 return nativeResponseValue;
18602 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
18604 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(orig: bigint): bigint {
18605 if(!isWasmInitialized) {
18606 throw new Error("initializeWasm() must be awaited first!");
18608 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(orig);
18609 return nativeResponseValue;
18611 // uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
18613 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: bigint): bigint {
18614 if(!isWasmInitialized) {
18615 throw new Error("initializeWasm() must be awaited first!");
18617 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
18618 return nativeResponseValue;
18620 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
18622 export function C2Tuple_PublicKeyTypeZ_clone(orig: bigint): bigint {
18623 if(!isWasmInitialized) {
18624 throw new Error("initializeWasm() must be awaited first!");
18626 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
18627 return nativeResponseValue;
18629 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
18631 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: bigint): bigint {
18632 if(!isWasmInitialized) {
18633 throw new Error("initializeWasm() must be awaited first!");
18635 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
18636 return nativeResponseValue;
18638 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
18640 export function C2Tuple_PublicKeyTypeZ_free(_res: bigint): void {
18641 if(!isWasmInitialized) {
18642 throw new Error("initializeWasm() must be awaited first!");
18644 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
18645 // debug statements here
18647 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
18649 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
18650 if(!isWasmInitialized) {
18651 throw new Error("initializeWasm() must be awaited first!");
18653 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
18654 // debug statements here
18656 // uint64_t C2Tuple_PublicKeyCVec_SocketAddressZZ_clone_ptr(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ *NONNULL_PTR arg);
18658 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_clone_ptr(arg: bigint): bigint {
18659 if(!isWasmInitialized) {
18660 throw new Error("initializeWasm() must be awaited first!");
18662 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_clone_ptr(arg);
18663 return nativeResponseValue;
18665 // struct LDKC2Tuple_PublicKeyCVec_SocketAddressZZ C2Tuple_PublicKeyCVec_SocketAddressZZ_clone(const struct LDKC2Tuple_PublicKeyCVec_SocketAddressZZ *NONNULL_PTR orig);
18667 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_clone(orig: bigint): bigint {
18668 if(!isWasmInitialized) {
18669 throw new Error("initializeWasm() must be awaited first!");
18671 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_clone(orig);
18672 return nativeResponseValue;
18674 // struct LDKC2Tuple_PublicKeyCVec_SocketAddressZZ C2Tuple_PublicKeyCVec_SocketAddressZZ_new(struct LDKPublicKey a, struct LDKCVec_SocketAddressZ b);
18676 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_new(a: number, b: number): bigint {
18677 if(!isWasmInitialized) {
18678 throw new Error("initializeWasm() must be awaited first!");
18680 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_new(a, b);
18681 return nativeResponseValue;
18683 // void C2Tuple_PublicKeyCVec_SocketAddressZZ_free(struct LDKC2Tuple_PublicKeyCVec_SocketAddressZZ _res);
18685 export function C2Tuple_PublicKeyCVec_SocketAddressZZ_free(_res: bigint): void {
18686 if(!isWasmInitialized) {
18687 throw new Error("initializeWasm() must be awaited first!");
18689 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCVec_SocketAddressZZ_free(_res);
18690 // debug statements here
18692 // void CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(struct LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ _res);
18694 export function CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(_res: number): void {
18695 if(!isWasmInitialized) {
18696 throw new Error("initializeWasm() must be awaited first!");
18698 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(_res);
18699 // debug statements here
18701 // struct LDKCOption_OnionMessageContentsZ COption_OnionMessageContentsZ_some(struct LDKOnionMessageContents o);
18703 export function COption_OnionMessageContentsZ_some(o: bigint): bigint {
18704 if(!isWasmInitialized) {
18705 throw new Error("initializeWasm() must be awaited first!");
18707 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_some(o);
18708 return nativeResponseValue;
18710 // struct LDKCOption_OnionMessageContentsZ COption_OnionMessageContentsZ_none(void);
18712 export function COption_OnionMessageContentsZ_none(): bigint {
18713 if(!isWasmInitialized) {
18714 throw new Error("initializeWasm() must be awaited first!");
18716 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_none();
18717 return nativeResponseValue;
18719 // void COption_OnionMessageContentsZ_free(struct LDKCOption_OnionMessageContentsZ _res);
18721 export function COption_OnionMessageContentsZ_free(_res: bigint): void {
18722 if(!isWasmInitialized) {
18723 throw new Error("initializeWasm() must be awaited first!");
18725 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_free(_res);
18726 // debug statements here
18728 // uint64_t COption_OnionMessageContentsZ_clone_ptr(LDKCOption_OnionMessageContentsZ *NONNULL_PTR arg);
18730 export function COption_OnionMessageContentsZ_clone_ptr(arg: bigint): bigint {
18731 if(!isWasmInitialized) {
18732 throw new Error("initializeWasm() must be awaited first!");
18734 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_clone_ptr(arg);
18735 return nativeResponseValue;
18737 // struct LDKCOption_OnionMessageContentsZ COption_OnionMessageContentsZ_clone(const struct LDKCOption_OnionMessageContentsZ *NONNULL_PTR orig);
18739 export function COption_OnionMessageContentsZ_clone(orig: bigint): bigint {
18740 if(!isWasmInitialized) {
18741 throw new Error("initializeWasm() must be awaited first!");
18743 const nativeResponseValue = wasm.TS_COption_OnionMessageContentsZ_clone(orig);
18744 return nativeResponseValue;
18746 // struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CResult_COption_OnionMessageContentsZDecodeErrorZ_ok(struct LDKCOption_OnionMessageContentsZ o);
18748 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_ok(o: bigint): bigint {
18749 if(!isWasmInitialized) {
18750 throw new Error("initializeWasm() must be awaited first!");
18752 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_ok(o);
18753 return nativeResponseValue;
18755 // struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CResult_COption_OnionMessageContentsZDecodeErrorZ_err(struct LDKDecodeError e);
18757 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_err(e: bigint): bigint {
18758 if(!isWasmInitialized) {
18759 throw new Error("initializeWasm() must be awaited first!");
18761 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_err(e);
18762 return nativeResponseValue;
18764 // bool CResult_COption_OnionMessageContentsZDecodeErrorZ_is_ok(const struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR o);
18766 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_is_ok(o: bigint): boolean {
18767 if(!isWasmInitialized) {
18768 throw new Error("initializeWasm() must be awaited first!");
18770 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_is_ok(o);
18771 return nativeResponseValue;
18773 // void CResult_COption_OnionMessageContentsZDecodeErrorZ_free(struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ _res);
18775 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_free(_res: bigint): void {
18776 if(!isWasmInitialized) {
18777 throw new Error("initializeWasm() must be awaited first!");
18779 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_free(_res);
18780 // debug statements here
18782 // uint64_t CResult_COption_OnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg);
18784 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18785 if(!isWasmInitialized) {
18786 throw new Error("initializeWasm() must be awaited first!");
18788 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_clone_ptr(arg);
18789 return nativeResponseValue;
18791 // struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CResult_COption_OnionMessageContentsZDecodeErrorZ_clone(const struct LDKCResult_COption_OnionMessageContentsZDecodeErrorZ *NONNULL_PTR orig);
18793 export function CResult_COption_OnionMessageContentsZDecodeErrorZ_clone(orig: bigint): bigint {
18794 if(!isWasmInitialized) {
18795 throw new Error("initializeWasm() must be awaited first!");
18797 const nativeResponseValue = wasm.TS_CResult_COption_OnionMessageContentsZDecodeErrorZ_clone(orig);
18798 return nativeResponseValue;
18800 // uint64_t C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone_ptr(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR arg);
18802 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone_ptr(arg: bigint): bigint {
18803 if(!isWasmInitialized) {
18804 throw new Error("initializeWasm() must be awaited first!");
18806 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone_ptr(arg);
18807 return nativeResponseValue;
18809 // struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone(const struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ *NONNULL_PTR orig);
18811 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone(orig: bigint): bigint {
18812 if(!isWasmInitialized) {
18813 throw new Error("initializeWasm() must be awaited first!");
18815 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_clone(orig);
18816 return nativeResponseValue;
18818 // struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ C3Tuple_OnionMessageContentsDestinationBlindedPathZ_new(struct LDKOnionMessageContents a, struct LDKDestination b, struct LDKBlindedPath c);
18820 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_new(a: bigint, b: bigint, c: bigint): bigint {
18821 if(!isWasmInitialized) {
18822 throw new Error("initializeWasm() must be awaited first!");
18824 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_new(a, b, c);
18825 return nativeResponseValue;
18827 // void C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(struct LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ _res);
18829 export function C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(_res: bigint): void {
18830 if(!isWasmInitialized) {
18831 throw new Error("initializeWasm() must be awaited first!");
18833 const nativeResponseValue = wasm.TS_C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(_res);
18834 // debug statements here
18836 // void CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(struct LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ _res);
18838 export function CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(_res: number): void {
18839 if(!isWasmInitialized) {
18840 throw new Error("initializeWasm() must be awaited first!");
18842 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(_res);
18843 // debug statements here
18845 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
18847 export function COption_TypeZ_some(o: bigint): bigint {
18848 if(!isWasmInitialized) {
18849 throw new Error("initializeWasm() must be awaited first!");
18851 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
18852 return nativeResponseValue;
18854 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
18856 export function COption_TypeZ_none(): bigint {
18857 if(!isWasmInitialized) {
18858 throw new Error("initializeWasm() must be awaited first!");
18860 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
18861 return nativeResponseValue;
18863 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
18865 export function COption_TypeZ_free(_res: bigint): void {
18866 if(!isWasmInitialized) {
18867 throw new Error("initializeWasm() must be awaited first!");
18869 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
18870 // debug statements here
18872 // uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
18874 export function COption_TypeZ_clone_ptr(arg: bigint): bigint {
18875 if(!isWasmInitialized) {
18876 throw new Error("initializeWasm() must be awaited first!");
18878 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
18879 return nativeResponseValue;
18881 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
18883 export function COption_TypeZ_clone(orig: bigint): bigint {
18884 if(!isWasmInitialized) {
18885 throw new Error("initializeWasm() must be awaited first!");
18887 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
18888 return nativeResponseValue;
18890 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
18892 export function CResult_COption_TypeZDecodeErrorZ_ok(o: bigint): bigint {
18893 if(!isWasmInitialized) {
18894 throw new Error("initializeWasm() must be awaited first!");
18896 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
18897 return nativeResponseValue;
18899 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
18901 export function CResult_COption_TypeZDecodeErrorZ_err(e: bigint): bigint {
18902 if(!isWasmInitialized) {
18903 throw new Error("initializeWasm() must be awaited first!");
18905 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
18906 return nativeResponseValue;
18908 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
18910 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: bigint): boolean {
18911 if(!isWasmInitialized) {
18912 throw new Error("initializeWasm() must be awaited first!");
18914 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
18915 return nativeResponseValue;
18917 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
18919 export function CResult_COption_TypeZDecodeErrorZ_free(_res: bigint): void {
18920 if(!isWasmInitialized) {
18921 throw new Error("initializeWasm() must be awaited first!");
18923 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
18924 // debug statements here
18926 // uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
18928 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
18929 if(!isWasmInitialized) {
18930 throw new Error("initializeWasm() must be awaited first!");
18932 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
18933 return nativeResponseValue;
18935 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
18937 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: bigint): bigint {
18938 if(!isWasmInitialized) {
18939 throw new Error("initializeWasm() must be awaited first!");
18941 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
18942 return nativeResponseValue;
18944 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_some(struct LDKSocketAddress o);
18946 export function COption_SocketAddressZ_some(o: bigint): bigint {
18947 if(!isWasmInitialized) {
18948 throw new Error("initializeWasm() must be awaited first!");
18950 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_some(o);
18951 return nativeResponseValue;
18953 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_none(void);
18955 export function COption_SocketAddressZ_none(): bigint {
18956 if(!isWasmInitialized) {
18957 throw new Error("initializeWasm() must be awaited first!");
18959 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_none();
18960 return nativeResponseValue;
18962 // void COption_SocketAddressZ_free(struct LDKCOption_SocketAddressZ _res);
18964 export function COption_SocketAddressZ_free(_res: bigint): void {
18965 if(!isWasmInitialized) {
18966 throw new Error("initializeWasm() must be awaited first!");
18968 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_free(_res);
18969 // debug statements here
18971 // uint64_t COption_SocketAddressZ_clone_ptr(LDKCOption_SocketAddressZ *NONNULL_PTR arg);
18973 export function COption_SocketAddressZ_clone_ptr(arg: bigint): bigint {
18974 if(!isWasmInitialized) {
18975 throw new Error("initializeWasm() must be awaited first!");
18977 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_clone_ptr(arg);
18978 return nativeResponseValue;
18980 // struct LDKCOption_SocketAddressZ COption_SocketAddressZ_clone(const struct LDKCOption_SocketAddressZ *NONNULL_PTR orig);
18982 export function COption_SocketAddressZ_clone(orig: bigint): bigint {
18983 if(!isWasmInitialized) {
18984 throw new Error("initializeWasm() must be awaited first!");
18986 const nativeResponseValue = wasm.TS_COption_SocketAddressZ_clone(orig);
18987 return nativeResponseValue;
18989 // uint64_t C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR arg);
18991 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(arg: bigint): bigint {
18992 if(!isWasmInitialized) {
18993 throw new Error("initializeWasm() must be awaited first!");
18995 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(arg);
18996 return nativeResponseValue;
18998 // struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(const struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR orig);
19000 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(orig: bigint): bigint {
19001 if(!isWasmInitialized) {
19002 throw new Error("initializeWasm() must be awaited first!");
19004 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(orig);
19005 return nativeResponseValue;
19007 // struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ C2Tuple_PublicKeyCOption_SocketAddressZZ_new(struct LDKPublicKey a, struct LDKCOption_SocketAddressZ b);
19009 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_new(a: number, b: bigint): bigint {
19010 if(!isWasmInitialized) {
19011 throw new Error("initializeWasm() must be awaited first!");
19013 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_new(a, b);
19014 return nativeResponseValue;
19016 // void C2Tuple_PublicKeyCOption_SocketAddressZZ_free(struct LDKC2Tuple_PublicKeyCOption_SocketAddressZZ _res);
19018 export function C2Tuple_PublicKeyCOption_SocketAddressZZ_free(_res: bigint): void {
19019 if(!isWasmInitialized) {
19020 throw new Error("initializeWasm() must be awaited first!");
19022 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_free(_res);
19023 // debug statements here
19025 // void CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(struct LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ _res);
19027 export function CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(_res: number): void {
19028 if(!isWasmInitialized) {
19029 throw new Error("initializeWasm() must be awaited first!");
19031 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(_res);
19032 // debug statements here
19034 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
19036 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): bigint {
19037 if(!isWasmInitialized) {
19038 throw new Error("initializeWasm() must be awaited first!");
19040 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
19041 return nativeResponseValue;
19043 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
19045 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: bigint): bigint {
19046 if(!isWasmInitialized) {
19047 throw new Error("initializeWasm() must be awaited first!");
19049 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
19050 return nativeResponseValue;
19052 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
19054 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: bigint): boolean {
19055 if(!isWasmInitialized) {
19056 throw new Error("initializeWasm() must be awaited first!");
19058 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
19059 return nativeResponseValue;
19061 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
19063 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: bigint): void {
19064 if(!isWasmInitialized) {
19065 throw new Error("initializeWasm() must be awaited first!");
19067 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
19068 // debug statements here
19070 // uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
19072 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
19073 if(!isWasmInitialized) {
19074 throw new Error("initializeWasm() must be awaited first!");
19076 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
19077 return nativeResponseValue;
19079 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
19081 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: bigint): bigint {
19082 if(!isWasmInitialized) {
19083 throw new Error("initializeWasm() must be awaited first!");
19085 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
19086 return nativeResponseValue;
19088 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
19090 export function CResult_NonePeerHandleErrorZ_ok(): bigint {
19091 if(!isWasmInitialized) {
19092 throw new Error("initializeWasm() must be awaited first!");
19094 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
19095 return nativeResponseValue;
19097 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
19099 export function CResult_NonePeerHandleErrorZ_err(e: bigint): bigint {
19100 if(!isWasmInitialized) {
19101 throw new Error("initializeWasm() must be awaited first!");
19103 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
19104 return nativeResponseValue;
19106 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
19108 export function CResult_NonePeerHandleErrorZ_is_ok(o: bigint): boolean {
19109 if(!isWasmInitialized) {
19110 throw new Error("initializeWasm() must be awaited first!");
19112 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
19113 return nativeResponseValue;
19115 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
19117 export function CResult_NonePeerHandleErrorZ_free(_res: bigint): void {
19118 if(!isWasmInitialized) {
19119 throw new Error("initializeWasm() must be awaited first!");
19121 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
19122 // debug statements here
19124 // uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
19126 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
19127 if(!isWasmInitialized) {
19128 throw new Error("initializeWasm() must be awaited first!");
19130 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
19131 return nativeResponseValue;
19133 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
19135 export function CResult_NonePeerHandleErrorZ_clone(orig: bigint): bigint {
19136 if(!isWasmInitialized) {
19137 throw new Error("initializeWasm() must be awaited first!");
19139 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
19140 return nativeResponseValue;
19142 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
19144 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): bigint {
19145 if(!isWasmInitialized) {
19146 throw new Error("initializeWasm() must be awaited first!");
19148 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
19149 return nativeResponseValue;
19151 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
19153 export function CResult_boolPeerHandleErrorZ_err(e: bigint): bigint {
19154 if(!isWasmInitialized) {
19155 throw new Error("initializeWasm() must be awaited first!");
19157 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
19158 return nativeResponseValue;
19160 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
19162 export function CResult_boolPeerHandleErrorZ_is_ok(o: bigint): boolean {
19163 if(!isWasmInitialized) {
19164 throw new Error("initializeWasm() must be awaited first!");
19166 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
19167 return nativeResponseValue;
19169 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
19171 export function CResult_boolPeerHandleErrorZ_free(_res: bigint): void {
19172 if(!isWasmInitialized) {
19173 throw new Error("initializeWasm() must be awaited first!");
19175 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
19176 // debug statements here
19178 // uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
19180 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: bigint): bigint {
19181 if(!isWasmInitialized) {
19182 throw new Error("initializeWasm() must be awaited first!");
19184 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
19185 return nativeResponseValue;
19187 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
19189 export function CResult_boolPeerHandleErrorZ_clone(orig: bigint): bigint {
19190 if(!isWasmInitialized) {
19191 throw new Error("initializeWasm() must be awaited first!");
19193 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
19194 return nativeResponseValue;
19196 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_ok(uint32_t o);
19198 export function CResult_u32GraphSyncErrorZ_ok(o: number): bigint {
19199 if(!isWasmInitialized) {
19200 throw new Error("initializeWasm() must be awaited first!");
19202 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_ok(o);
19203 return nativeResponseValue;
19205 // struct LDKCResult_u32GraphSyncErrorZ CResult_u32GraphSyncErrorZ_err(struct LDKGraphSyncError e);
19207 export function CResult_u32GraphSyncErrorZ_err(e: bigint): bigint {
19208 if(!isWasmInitialized) {
19209 throw new Error("initializeWasm() must be awaited first!");
19211 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_err(e);
19212 return nativeResponseValue;
19214 // bool CResult_u32GraphSyncErrorZ_is_ok(const struct LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR o);
19216 export function CResult_u32GraphSyncErrorZ_is_ok(o: bigint): boolean {
19217 if(!isWasmInitialized) {
19218 throw new Error("initializeWasm() must be awaited first!");
19220 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_is_ok(o);
19221 return nativeResponseValue;
19223 // void CResult_u32GraphSyncErrorZ_free(struct LDKCResult_u32GraphSyncErrorZ _res);
19225 export function CResult_u32GraphSyncErrorZ_free(_res: bigint): void {
19226 if(!isWasmInitialized) {
19227 throw new Error("initializeWasm() must be awaited first!");
19229 const nativeResponseValue = wasm.TS_CResult_u32GraphSyncErrorZ_free(_res);
19230 // debug statements here
19232 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_ok(struct LDKCVec_u8Z o);
19234 export function CResult_CVec_u8ZIOErrorZ_ok(o: number): bigint {
19235 if(!isWasmInitialized) {
19236 throw new Error("initializeWasm() must be awaited first!");
19238 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_ok(o);
19239 return nativeResponseValue;
19241 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_err(enum LDKIOError e);
19243 export function CResult_CVec_u8ZIOErrorZ_err(e: IOError): bigint {
19244 if(!isWasmInitialized) {
19245 throw new Error("initializeWasm() must be awaited first!");
19247 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_err(e);
19248 return nativeResponseValue;
19250 // bool CResult_CVec_u8ZIOErrorZ_is_ok(const struct LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR o);
19252 export function CResult_CVec_u8ZIOErrorZ_is_ok(o: bigint): boolean {
19253 if(!isWasmInitialized) {
19254 throw new Error("initializeWasm() must be awaited first!");
19256 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_is_ok(o);
19257 return nativeResponseValue;
19259 // void CResult_CVec_u8ZIOErrorZ_free(struct LDKCResult_CVec_u8ZIOErrorZ _res);
19261 export function CResult_CVec_u8ZIOErrorZ_free(_res: bigint): void {
19262 if(!isWasmInitialized) {
19263 throw new Error("initializeWasm() must be awaited first!");
19265 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_free(_res);
19266 // debug statements here
19268 // uint64_t CResult_CVec_u8ZIOErrorZ_clone_ptr(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR arg);
19270 export function CResult_CVec_u8ZIOErrorZ_clone_ptr(arg: bigint): bigint {
19271 if(!isWasmInitialized) {
19272 throw new Error("initializeWasm() must be awaited first!");
19274 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_clone_ptr(arg);
19275 return nativeResponseValue;
19277 // struct LDKCResult_CVec_u8ZIOErrorZ CResult_CVec_u8ZIOErrorZ_clone(const struct LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR orig);
19279 export function CResult_CVec_u8ZIOErrorZ_clone(orig: bigint): bigint {
19280 if(!isWasmInitialized) {
19281 throw new Error("initializeWasm() must be awaited first!");
19283 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZIOErrorZ_clone(orig);
19284 return nativeResponseValue;
19286 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_ok(void);
19288 export function CResult_NoneIOErrorZ_ok(): bigint {
19289 if(!isWasmInitialized) {
19290 throw new Error("initializeWasm() must be awaited first!");
19292 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_ok();
19293 return nativeResponseValue;
19295 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_err(enum LDKIOError e);
19297 export function CResult_NoneIOErrorZ_err(e: IOError): bigint {
19298 if(!isWasmInitialized) {
19299 throw new Error("initializeWasm() must be awaited first!");
19301 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_err(e);
19302 return nativeResponseValue;
19304 // bool CResult_NoneIOErrorZ_is_ok(const struct LDKCResult_NoneIOErrorZ *NONNULL_PTR o);
19306 export function CResult_NoneIOErrorZ_is_ok(o: bigint): boolean {
19307 if(!isWasmInitialized) {
19308 throw new Error("initializeWasm() must be awaited first!");
19310 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_is_ok(o);
19311 return nativeResponseValue;
19313 // void CResult_NoneIOErrorZ_free(struct LDKCResult_NoneIOErrorZ _res);
19315 export function CResult_NoneIOErrorZ_free(_res: bigint): void {
19316 if(!isWasmInitialized) {
19317 throw new Error("initializeWasm() must be awaited first!");
19319 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_free(_res);
19320 // debug statements here
19322 // uint64_t CResult_NoneIOErrorZ_clone_ptr(LDKCResult_NoneIOErrorZ *NONNULL_PTR arg);
19324 export function CResult_NoneIOErrorZ_clone_ptr(arg: bigint): bigint {
19325 if(!isWasmInitialized) {
19326 throw new Error("initializeWasm() must be awaited first!");
19328 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_clone_ptr(arg);
19329 return nativeResponseValue;
19331 // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_clone(const struct LDKCResult_NoneIOErrorZ *NONNULL_PTR orig);
19333 export function CResult_NoneIOErrorZ_clone(orig: bigint): bigint {
19334 if(!isWasmInitialized) {
19335 throw new Error("initializeWasm() must be awaited first!");
19337 const nativeResponseValue = wasm.TS_CResult_NoneIOErrorZ_clone(orig);
19338 return nativeResponseValue;
19340 // void CVec_StrZ_free(struct LDKCVec_StrZ _res);
19342 export function CVec_StrZ_free(_res: number): void {
19343 if(!isWasmInitialized) {
19344 throw new Error("initializeWasm() must be awaited first!");
19346 const nativeResponseValue = wasm.TS_CVec_StrZ_free(_res);
19347 // debug statements here
19349 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_ok(struct LDKCVec_StrZ o);
19351 export function CResult_CVec_StrZIOErrorZ_ok(o: number): bigint {
19352 if(!isWasmInitialized) {
19353 throw new Error("initializeWasm() must be awaited first!");
19355 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_ok(o);
19356 return nativeResponseValue;
19358 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_err(enum LDKIOError e);
19360 export function CResult_CVec_StrZIOErrorZ_err(e: IOError): bigint {
19361 if(!isWasmInitialized) {
19362 throw new Error("initializeWasm() must be awaited first!");
19364 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_err(e);
19365 return nativeResponseValue;
19367 // bool CResult_CVec_StrZIOErrorZ_is_ok(const struct LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR o);
19369 export function CResult_CVec_StrZIOErrorZ_is_ok(o: bigint): boolean {
19370 if(!isWasmInitialized) {
19371 throw new Error("initializeWasm() must be awaited first!");
19373 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_is_ok(o);
19374 return nativeResponseValue;
19376 // void CResult_CVec_StrZIOErrorZ_free(struct LDKCResult_CVec_StrZIOErrorZ _res);
19378 export function CResult_CVec_StrZIOErrorZ_free(_res: bigint): void {
19379 if(!isWasmInitialized) {
19380 throw new Error("initializeWasm() must be awaited first!");
19382 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_free(_res);
19383 // debug statements here
19385 // uint64_t CResult_CVec_StrZIOErrorZ_clone_ptr(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR arg);
19387 export function CResult_CVec_StrZIOErrorZ_clone_ptr(arg: bigint): bigint {
19388 if(!isWasmInitialized) {
19389 throw new Error("initializeWasm() must be awaited first!");
19391 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_clone_ptr(arg);
19392 return nativeResponseValue;
19394 // struct LDKCResult_CVec_StrZIOErrorZ CResult_CVec_StrZIOErrorZ_clone(const struct LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR orig);
19396 export function CResult_CVec_StrZIOErrorZ_clone(orig: bigint): bigint {
19397 if(!isWasmInitialized) {
19398 throw new Error("initializeWasm() must be awaited first!");
19400 const nativeResponseValue = wasm.TS_CResult_CVec_StrZIOErrorZ_clone(orig);
19401 return nativeResponseValue;
19403 // void CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ _res);
19405 export function CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(_res: number): void {
19406 if(!isWasmInitialized) {
19407 throw new Error("initializeWasm() must be awaited first!");
19409 const nativeResponseValue = wasm.TS_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(_res);
19410 // debug statements here
19412 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ o);
19414 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(o: number): bigint {
19415 if(!isWasmInitialized) {
19416 throw new Error("initializeWasm() must be awaited first!");
19418 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(o);
19419 return nativeResponseValue;
19421 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(enum LDKIOError e);
19423 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(e: IOError): bigint {
19424 if(!isWasmInitialized) {
19425 throw new Error("initializeWasm() must be awaited first!");
19427 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(e);
19428 return nativeResponseValue;
19430 // bool CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR o);
19432 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(o: bigint): boolean {
19433 if(!isWasmInitialized) {
19434 throw new Error("initializeWasm() must be awaited first!");
19436 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(o);
19437 return nativeResponseValue;
19439 // void CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ _res);
19441 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(_res: bigint): void {
19442 if(!isWasmInitialized) {
19443 throw new Error("initializeWasm() must be awaited first!");
19445 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(_res);
19446 // debug statements here
19448 // uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR arg);
19450 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(arg: bigint): bigint {
19451 if(!isWasmInitialized) {
19452 throw new Error("initializeWasm() must be awaited first!");
19454 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(arg);
19455 return nativeResponseValue;
19457 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(const struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR orig);
19459 export function CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(orig: bigint): bigint {
19460 if(!isWasmInitialized) {
19461 throw new Error("initializeWasm() must be awaited first!");
19463 const nativeResponseValue = wasm.TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(orig);
19464 return nativeResponseValue;
19466 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ o);
19468 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(o: bigint): bigint {
19469 if(!isWasmInitialized) {
19470 throw new Error("initializeWasm() must be awaited first!");
19472 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(o);
19473 return nativeResponseValue;
19475 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(enum LDKIOError e);
19477 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(e: IOError): bigint {
19478 if(!isWasmInitialized) {
19479 throw new Error("initializeWasm() must be awaited first!");
19481 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(e);
19482 return nativeResponseValue;
19484 // bool CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR o);
19486 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(o: bigint): boolean {
19487 if(!isWasmInitialized) {
19488 throw new Error("initializeWasm() must be awaited first!");
19490 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(o);
19491 return nativeResponseValue;
19493 // void CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ _res);
19495 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(_res: bigint): void {
19496 if(!isWasmInitialized) {
19497 throw new Error("initializeWasm() must be awaited first!");
19499 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(_res);
19500 // debug statements here
19502 // uint64_t CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR arg);
19504 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(arg: bigint): bigint {
19505 if(!isWasmInitialized) {
19506 throw new Error("initializeWasm() must be awaited first!");
19508 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(arg);
19509 return nativeResponseValue;
19511 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(const struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR orig);
19513 export function CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(orig: bigint): bigint {
19514 if(!isWasmInitialized) {
19515 throw new Error("initializeWasm() must be awaited first!");
19517 const nativeResponseValue = wasm.TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(orig);
19518 return nativeResponseValue;
19520 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_some(struct LDKSecretKey o);
19522 export function COption_SecretKeyZ_some(o: number): bigint {
19523 if(!isWasmInitialized) {
19524 throw new Error("initializeWasm() must be awaited first!");
19526 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_some(o);
19527 return nativeResponseValue;
19529 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_none(void);
19531 export function COption_SecretKeyZ_none(): bigint {
19532 if(!isWasmInitialized) {
19533 throw new Error("initializeWasm() must be awaited first!");
19535 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_none();
19536 return nativeResponseValue;
19538 // void COption_SecretKeyZ_free(struct LDKCOption_SecretKeyZ _res);
19540 export function COption_SecretKeyZ_free(_res: bigint): void {
19541 if(!isWasmInitialized) {
19542 throw new Error("initializeWasm() must be awaited first!");
19544 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_free(_res);
19545 // debug statements here
19547 // uint64_t COption_SecretKeyZ_clone_ptr(LDKCOption_SecretKeyZ *NONNULL_PTR arg);
19549 export function COption_SecretKeyZ_clone_ptr(arg: bigint): bigint {
19550 if(!isWasmInitialized) {
19551 throw new Error("initializeWasm() must be awaited first!");
19553 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_clone_ptr(arg);
19554 return nativeResponseValue;
19556 // struct LDKCOption_SecretKeyZ COption_SecretKeyZ_clone(const struct LDKCOption_SecretKeyZ *NONNULL_PTR orig);
19558 export function COption_SecretKeyZ_clone(orig: bigint): bigint {
19559 if(!isWasmInitialized) {
19560 throw new Error("initializeWasm() must be awaited first!");
19562 const nativeResponseValue = wasm.TS_COption_SecretKeyZ_clone(orig);
19563 return nativeResponseValue;
19565 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_ok(struct LDKVerifiedInvoiceRequest o);
19567 export function CResult_VerifiedInvoiceRequestNoneZ_ok(o: bigint): bigint {
19568 if(!isWasmInitialized) {
19569 throw new Error("initializeWasm() must be awaited first!");
19571 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_ok(o);
19572 return nativeResponseValue;
19574 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_err(void);
19576 export function CResult_VerifiedInvoiceRequestNoneZ_err(): bigint {
19577 if(!isWasmInitialized) {
19578 throw new Error("initializeWasm() must be awaited first!");
19580 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_err();
19581 return nativeResponseValue;
19583 // bool CResult_VerifiedInvoiceRequestNoneZ_is_ok(const struct LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR o);
19585 export function CResult_VerifiedInvoiceRequestNoneZ_is_ok(o: bigint): boolean {
19586 if(!isWasmInitialized) {
19587 throw new Error("initializeWasm() must be awaited first!");
19589 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_is_ok(o);
19590 return nativeResponseValue;
19592 // void CResult_VerifiedInvoiceRequestNoneZ_free(struct LDKCResult_VerifiedInvoiceRequestNoneZ _res);
19594 export function CResult_VerifiedInvoiceRequestNoneZ_free(_res: bigint): void {
19595 if(!isWasmInitialized) {
19596 throw new Error("initializeWasm() must be awaited first!");
19598 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_free(_res);
19599 // debug statements here
19601 // uint64_t CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR arg);
19603 export function CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(arg: bigint): bigint {
19604 if(!isWasmInitialized) {
19605 throw new Error("initializeWasm() must be awaited first!");
19607 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(arg);
19608 return nativeResponseValue;
19610 // struct LDKCResult_VerifiedInvoiceRequestNoneZ CResult_VerifiedInvoiceRequestNoneZ_clone(const struct LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR orig);
19612 export function CResult_VerifiedInvoiceRequestNoneZ_clone(orig: bigint): bigint {
19613 if(!isWasmInitialized) {
19614 throw new Error("initializeWasm() must be awaited first!");
19616 const nativeResponseValue = wasm.TS_CResult_VerifiedInvoiceRequestNoneZ_clone(orig);
19617 return nativeResponseValue;
19619 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
19621 export function COption_NoneZ_some(): COption_NoneZ {
19622 if(!isWasmInitialized) {
19623 throw new Error("initializeWasm() must be awaited first!");
19625 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
19626 return nativeResponseValue;
19628 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
19630 export function COption_NoneZ_none(): COption_NoneZ {
19631 if(!isWasmInitialized) {
19632 throw new Error("initializeWasm() must be awaited first!");
19634 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
19635 return nativeResponseValue;
19637 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
19639 export function COption_NoneZ_free(_res: COption_NoneZ): void {
19640 if(!isWasmInitialized) {
19641 throw new Error("initializeWasm() must be awaited first!");
19643 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
19644 // debug statements here
19646 // void CVec_WitnessZ_free(struct LDKCVec_WitnessZ _res);
19648 export function CVec_WitnessZ_free(_res: number): void {
19649 if(!isWasmInitialized) {
19650 throw new Error("initializeWasm() must be awaited first!");
19652 const nativeResponseValue = wasm.TS_CVec_WitnessZ_free(_res);
19653 // debug statements here
19655 // struct LDKCOption_i64Z COption_i64Z_some(int64_t o);
19657 export function COption_i64Z_some(o: bigint): bigint {
19658 if(!isWasmInitialized) {
19659 throw new Error("initializeWasm() must be awaited first!");
19661 const nativeResponseValue = wasm.TS_COption_i64Z_some(o);
19662 return nativeResponseValue;
19664 // struct LDKCOption_i64Z COption_i64Z_none(void);
19666 export function COption_i64Z_none(): bigint {
19667 if(!isWasmInitialized) {
19668 throw new Error("initializeWasm() must be awaited first!");
19670 const nativeResponseValue = wasm.TS_COption_i64Z_none();
19671 return nativeResponseValue;
19673 // void COption_i64Z_free(struct LDKCOption_i64Z _res);
19675 export function COption_i64Z_free(_res: bigint): void {
19676 if(!isWasmInitialized) {
19677 throw new Error("initializeWasm() must be awaited first!");
19679 const nativeResponseValue = wasm.TS_COption_i64Z_free(_res);
19680 // debug statements here
19682 // uint64_t COption_i64Z_clone_ptr(LDKCOption_i64Z *NONNULL_PTR arg);
19684 export function COption_i64Z_clone_ptr(arg: bigint): bigint {
19685 if(!isWasmInitialized) {
19686 throw new Error("initializeWasm() must be awaited first!");
19688 const nativeResponseValue = wasm.TS_COption_i64Z_clone_ptr(arg);
19689 return nativeResponseValue;
19691 // struct LDKCOption_i64Z COption_i64Z_clone(const struct LDKCOption_i64Z *NONNULL_PTR orig);
19693 export function COption_i64Z_clone(orig: bigint): bigint {
19694 if(!isWasmInitialized) {
19695 throw new Error("initializeWasm() must be awaited first!");
19697 const nativeResponseValue = wasm.TS_COption_i64Z_clone(orig);
19698 return nativeResponseValue;
19700 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_ok(struct LDKSocketAddress o);
19702 export function CResult_SocketAddressDecodeErrorZ_ok(o: bigint): bigint {
19703 if(!isWasmInitialized) {
19704 throw new Error("initializeWasm() must be awaited first!");
19706 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_ok(o);
19707 return nativeResponseValue;
19709 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_err(struct LDKDecodeError e);
19711 export function CResult_SocketAddressDecodeErrorZ_err(e: bigint): bigint {
19712 if(!isWasmInitialized) {
19713 throw new Error("initializeWasm() must be awaited first!");
19715 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_err(e);
19716 return nativeResponseValue;
19718 // bool CResult_SocketAddressDecodeErrorZ_is_ok(const struct LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR o);
19720 export function CResult_SocketAddressDecodeErrorZ_is_ok(o: bigint): boolean {
19721 if(!isWasmInitialized) {
19722 throw new Error("initializeWasm() must be awaited first!");
19724 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_is_ok(o);
19725 return nativeResponseValue;
19727 // void CResult_SocketAddressDecodeErrorZ_free(struct LDKCResult_SocketAddressDecodeErrorZ _res);
19729 export function CResult_SocketAddressDecodeErrorZ_free(_res: bigint): void {
19730 if(!isWasmInitialized) {
19731 throw new Error("initializeWasm() must be awaited first!");
19733 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_free(_res);
19734 // debug statements here
19736 // uint64_t CResult_SocketAddressDecodeErrorZ_clone_ptr(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR arg);
19738 export function CResult_SocketAddressDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19739 if(!isWasmInitialized) {
19740 throw new Error("initializeWasm() must be awaited first!");
19742 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_clone_ptr(arg);
19743 return nativeResponseValue;
19745 // struct LDKCResult_SocketAddressDecodeErrorZ CResult_SocketAddressDecodeErrorZ_clone(const struct LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR orig);
19747 export function CResult_SocketAddressDecodeErrorZ_clone(orig: bigint): bigint {
19748 if(!isWasmInitialized) {
19749 throw new Error("initializeWasm() must be awaited first!");
19751 const nativeResponseValue = wasm.TS_CResult_SocketAddressDecodeErrorZ_clone(orig);
19752 return nativeResponseValue;
19754 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_ok(struct LDKSocketAddress o);
19756 export function CResult_SocketAddressSocketAddressParseErrorZ_ok(o: bigint): bigint {
19757 if(!isWasmInitialized) {
19758 throw new Error("initializeWasm() must be awaited first!");
19760 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_ok(o);
19761 return nativeResponseValue;
19763 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_err(enum LDKSocketAddressParseError e);
19765 export function CResult_SocketAddressSocketAddressParseErrorZ_err(e: SocketAddressParseError): bigint {
19766 if(!isWasmInitialized) {
19767 throw new Error("initializeWasm() must be awaited first!");
19769 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_err(e);
19770 return nativeResponseValue;
19772 // bool CResult_SocketAddressSocketAddressParseErrorZ_is_ok(const struct LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR o);
19774 export function CResult_SocketAddressSocketAddressParseErrorZ_is_ok(o: bigint): boolean {
19775 if(!isWasmInitialized) {
19776 throw new Error("initializeWasm() must be awaited first!");
19778 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_is_ok(o);
19779 return nativeResponseValue;
19781 // void CResult_SocketAddressSocketAddressParseErrorZ_free(struct LDKCResult_SocketAddressSocketAddressParseErrorZ _res);
19783 export function CResult_SocketAddressSocketAddressParseErrorZ_free(_res: bigint): void {
19784 if(!isWasmInitialized) {
19785 throw new Error("initializeWasm() must be awaited first!");
19787 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_free(_res);
19788 // debug statements here
19790 // uint64_t CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR arg);
19792 export function CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(arg: bigint): bigint {
19793 if(!isWasmInitialized) {
19794 throw new Error("initializeWasm() must be awaited first!");
19796 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(arg);
19797 return nativeResponseValue;
19799 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ CResult_SocketAddressSocketAddressParseErrorZ_clone(const struct LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR orig);
19801 export function CResult_SocketAddressSocketAddressParseErrorZ_clone(orig: bigint): bigint {
19802 if(!isWasmInitialized) {
19803 throw new Error("initializeWasm() must be awaited first!");
19805 const nativeResponseValue = wasm.TS_CResult_SocketAddressSocketAddressParseErrorZ_clone(orig);
19806 return nativeResponseValue;
19808 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
19810 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
19811 if(!isWasmInitialized) {
19812 throw new Error("initializeWasm() must be awaited first!");
19814 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
19815 // debug statements here
19817 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
19819 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
19820 if(!isWasmInitialized) {
19821 throw new Error("initializeWasm() must be awaited first!");
19823 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
19824 // debug statements here
19826 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
19828 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
19829 if(!isWasmInitialized) {
19830 throw new Error("initializeWasm() must be awaited first!");
19832 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
19833 // debug statements here
19835 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
19837 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
19838 if(!isWasmInitialized) {
19839 throw new Error("initializeWasm() must be awaited first!");
19841 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
19842 // debug statements here
19844 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
19846 export function CResult_AcceptChannelDecodeErrorZ_ok(o: bigint): bigint {
19847 if(!isWasmInitialized) {
19848 throw new Error("initializeWasm() must be awaited first!");
19850 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
19851 return nativeResponseValue;
19853 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
19855 export function CResult_AcceptChannelDecodeErrorZ_err(e: bigint): bigint {
19856 if(!isWasmInitialized) {
19857 throw new Error("initializeWasm() must be awaited first!");
19859 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
19860 return nativeResponseValue;
19862 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
19864 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: bigint): boolean {
19865 if(!isWasmInitialized) {
19866 throw new Error("initializeWasm() must be awaited first!");
19868 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
19869 return nativeResponseValue;
19871 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
19873 export function CResult_AcceptChannelDecodeErrorZ_free(_res: bigint): void {
19874 if(!isWasmInitialized) {
19875 throw new Error("initializeWasm() must be awaited first!");
19877 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
19878 // debug statements here
19880 // uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
19882 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19883 if(!isWasmInitialized) {
19884 throw new Error("initializeWasm() must be awaited first!");
19886 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
19887 return nativeResponseValue;
19889 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
19891 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: bigint): bigint {
19892 if(!isWasmInitialized) {
19893 throw new Error("initializeWasm() must be awaited first!");
19895 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
19896 return nativeResponseValue;
19898 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_ok(struct LDKAcceptChannelV2 o);
19900 export function CResult_AcceptChannelV2DecodeErrorZ_ok(o: bigint): bigint {
19901 if(!isWasmInitialized) {
19902 throw new Error("initializeWasm() must be awaited first!");
19904 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_ok(o);
19905 return nativeResponseValue;
19907 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_err(struct LDKDecodeError e);
19909 export function CResult_AcceptChannelV2DecodeErrorZ_err(e: bigint): bigint {
19910 if(!isWasmInitialized) {
19911 throw new Error("initializeWasm() must be awaited first!");
19913 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_err(e);
19914 return nativeResponseValue;
19916 // bool CResult_AcceptChannelV2DecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR o);
19918 export function CResult_AcceptChannelV2DecodeErrorZ_is_ok(o: bigint): boolean {
19919 if(!isWasmInitialized) {
19920 throw new Error("initializeWasm() must be awaited first!");
19922 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_is_ok(o);
19923 return nativeResponseValue;
19925 // void CResult_AcceptChannelV2DecodeErrorZ_free(struct LDKCResult_AcceptChannelV2DecodeErrorZ _res);
19927 export function CResult_AcceptChannelV2DecodeErrorZ_free(_res: bigint): void {
19928 if(!isWasmInitialized) {
19929 throw new Error("initializeWasm() must be awaited first!");
19931 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_free(_res);
19932 // debug statements here
19934 // uint64_t CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR arg);
19936 export function CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(arg: bigint): bigint {
19937 if(!isWasmInitialized) {
19938 throw new Error("initializeWasm() must be awaited first!");
19940 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(arg);
19941 return nativeResponseValue;
19943 // struct LDKCResult_AcceptChannelV2DecodeErrorZ CResult_AcceptChannelV2DecodeErrorZ_clone(const struct LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR orig);
19945 export function CResult_AcceptChannelV2DecodeErrorZ_clone(orig: bigint): bigint {
19946 if(!isWasmInitialized) {
19947 throw new Error("initializeWasm() must be awaited first!");
19949 const nativeResponseValue = wasm.TS_CResult_AcceptChannelV2DecodeErrorZ_clone(orig);
19950 return nativeResponseValue;
19952 // struct LDKCResult_StfuDecodeErrorZ CResult_StfuDecodeErrorZ_ok(struct LDKStfu o);
19954 export function CResult_StfuDecodeErrorZ_ok(o: bigint): bigint {
19955 if(!isWasmInitialized) {
19956 throw new Error("initializeWasm() must be awaited first!");
19958 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_ok(o);
19959 return nativeResponseValue;
19961 // struct LDKCResult_StfuDecodeErrorZ CResult_StfuDecodeErrorZ_err(struct LDKDecodeError e);
19963 export function CResult_StfuDecodeErrorZ_err(e: bigint): bigint {
19964 if(!isWasmInitialized) {
19965 throw new Error("initializeWasm() must be awaited first!");
19967 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_err(e);
19968 return nativeResponseValue;
19970 // bool CResult_StfuDecodeErrorZ_is_ok(const struct LDKCResult_StfuDecodeErrorZ *NONNULL_PTR o);
19972 export function CResult_StfuDecodeErrorZ_is_ok(o: bigint): boolean {
19973 if(!isWasmInitialized) {
19974 throw new Error("initializeWasm() must be awaited first!");
19976 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_is_ok(o);
19977 return nativeResponseValue;
19979 // void CResult_StfuDecodeErrorZ_free(struct LDKCResult_StfuDecodeErrorZ _res);
19981 export function CResult_StfuDecodeErrorZ_free(_res: bigint): void {
19982 if(!isWasmInitialized) {
19983 throw new Error("initializeWasm() must be awaited first!");
19985 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_free(_res);
19986 // debug statements here
19988 // uint64_t CResult_StfuDecodeErrorZ_clone_ptr(LDKCResult_StfuDecodeErrorZ *NONNULL_PTR arg);
19990 export function CResult_StfuDecodeErrorZ_clone_ptr(arg: bigint): bigint {
19991 if(!isWasmInitialized) {
19992 throw new Error("initializeWasm() must be awaited first!");
19994 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_clone_ptr(arg);
19995 return nativeResponseValue;
19997 // struct LDKCResult_StfuDecodeErrorZ CResult_StfuDecodeErrorZ_clone(const struct LDKCResult_StfuDecodeErrorZ *NONNULL_PTR orig);
19999 export function CResult_StfuDecodeErrorZ_clone(orig: bigint): bigint {
20000 if(!isWasmInitialized) {
20001 throw new Error("initializeWasm() must be awaited first!");
20003 const nativeResponseValue = wasm.TS_CResult_StfuDecodeErrorZ_clone(orig);
20004 return nativeResponseValue;
20006 // struct LDKCResult_SpliceDecodeErrorZ CResult_SpliceDecodeErrorZ_ok(struct LDKSplice o);
20008 export function CResult_SpliceDecodeErrorZ_ok(o: bigint): bigint {
20009 if(!isWasmInitialized) {
20010 throw new Error("initializeWasm() must be awaited first!");
20012 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_ok(o);
20013 return nativeResponseValue;
20015 // struct LDKCResult_SpliceDecodeErrorZ CResult_SpliceDecodeErrorZ_err(struct LDKDecodeError e);
20017 export function CResult_SpliceDecodeErrorZ_err(e: bigint): bigint {
20018 if(!isWasmInitialized) {
20019 throw new Error("initializeWasm() must be awaited first!");
20021 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_err(e);
20022 return nativeResponseValue;
20024 // bool CResult_SpliceDecodeErrorZ_is_ok(const struct LDKCResult_SpliceDecodeErrorZ *NONNULL_PTR o);
20026 export function CResult_SpliceDecodeErrorZ_is_ok(o: bigint): boolean {
20027 if(!isWasmInitialized) {
20028 throw new Error("initializeWasm() must be awaited first!");
20030 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_is_ok(o);
20031 return nativeResponseValue;
20033 // void CResult_SpliceDecodeErrorZ_free(struct LDKCResult_SpliceDecodeErrorZ _res);
20035 export function CResult_SpliceDecodeErrorZ_free(_res: bigint): void {
20036 if(!isWasmInitialized) {
20037 throw new Error("initializeWasm() must be awaited first!");
20039 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_free(_res);
20040 // debug statements here
20042 // uint64_t CResult_SpliceDecodeErrorZ_clone_ptr(LDKCResult_SpliceDecodeErrorZ *NONNULL_PTR arg);
20044 export function CResult_SpliceDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20045 if(!isWasmInitialized) {
20046 throw new Error("initializeWasm() must be awaited first!");
20048 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_clone_ptr(arg);
20049 return nativeResponseValue;
20051 // struct LDKCResult_SpliceDecodeErrorZ CResult_SpliceDecodeErrorZ_clone(const struct LDKCResult_SpliceDecodeErrorZ *NONNULL_PTR orig);
20053 export function CResult_SpliceDecodeErrorZ_clone(orig: bigint): bigint {
20054 if(!isWasmInitialized) {
20055 throw new Error("initializeWasm() must be awaited first!");
20057 const nativeResponseValue = wasm.TS_CResult_SpliceDecodeErrorZ_clone(orig);
20058 return nativeResponseValue;
20060 // struct LDKCResult_SpliceAckDecodeErrorZ CResult_SpliceAckDecodeErrorZ_ok(struct LDKSpliceAck o);
20062 export function CResult_SpliceAckDecodeErrorZ_ok(o: bigint): bigint {
20063 if(!isWasmInitialized) {
20064 throw new Error("initializeWasm() must be awaited first!");
20066 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_ok(o);
20067 return nativeResponseValue;
20069 // struct LDKCResult_SpliceAckDecodeErrorZ CResult_SpliceAckDecodeErrorZ_err(struct LDKDecodeError e);
20071 export function CResult_SpliceAckDecodeErrorZ_err(e: bigint): bigint {
20072 if(!isWasmInitialized) {
20073 throw new Error("initializeWasm() must be awaited first!");
20075 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_err(e);
20076 return nativeResponseValue;
20078 // bool CResult_SpliceAckDecodeErrorZ_is_ok(const struct LDKCResult_SpliceAckDecodeErrorZ *NONNULL_PTR o);
20080 export function CResult_SpliceAckDecodeErrorZ_is_ok(o: bigint): boolean {
20081 if(!isWasmInitialized) {
20082 throw new Error("initializeWasm() must be awaited first!");
20084 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_is_ok(o);
20085 return nativeResponseValue;
20087 // void CResult_SpliceAckDecodeErrorZ_free(struct LDKCResult_SpliceAckDecodeErrorZ _res);
20089 export function CResult_SpliceAckDecodeErrorZ_free(_res: bigint): void {
20090 if(!isWasmInitialized) {
20091 throw new Error("initializeWasm() must be awaited first!");
20093 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_free(_res);
20094 // debug statements here
20096 // uint64_t CResult_SpliceAckDecodeErrorZ_clone_ptr(LDKCResult_SpliceAckDecodeErrorZ *NONNULL_PTR arg);
20098 export function CResult_SpliceAckDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20099 if(!isWasmInitialized) {
20100 throw new Error("initializeWasm() must be awaited first!");
20102 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_clone_ptr(arg);
20103 return nativeResponseValue;
20105 // struct LDKCResult_SpliceAckDecodeErrorZ CResult_SpliceAckDecodeErrorZ_clone(const struct LDKCResult_SpliceAckDecodeErrorZ *NONNULL_PTR orig);
20107 export function CResult_SpliceAckDecodeErrorZ_clone(orig: bigint): bigint {
20108 if(!isWasmInitialized) {
20109 throw new Error("initializeWasm() must be awaited first!");
20111 const nativeResponseValue = wasm.TS_CResult_SpliceAckDecodeErrorZ_clone(orig);
20112 return nativeResponseValue;
20114 // struct LDKCResult_SpliceLockedDecodeErrorZ CResult_SpliceLockedDecodeErrorZ_ok(struct LDKSpliceLocked o);
20116 export function CResult_SpliceLockedDecodeErrorZ_ok(o: bigint): bigint {
20117 if(!isWasmInitialized) {
20118 throw new Error("initializeWasm() must be awaited first!");
20120 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_ok(o);
20121 return nativeResponseValue;
20123 // struct LDKCResult_SpliceLockedDecodeErrorZ CResult_SpliceLockedDecodeErrorZ_err(struct LDKDecodeError e);
20125 export function CResult_SpliceLockedDecodeErrorZ_err(e: bigint): bigint {
20126 if(!isWasmInitialized) {
20127 throw new Error("initializeWasm() must be awaited first!");
20129 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_err(e);
20130 return nativeResponseValue;
20132 // bool CResult_SpliceLockedDecodeErrorZ_is_ok(const struct LDKCResult_SpliceLockedDecodeErrorZ *NONNULL_PTR o);
20134 export function CResult_SpliceLockedDecodeErrorZ_is_ok(o: bigint): boolean {
20135 if(!isWasmInitialized) {
20136 throw new Error("initializeWasm() must be awaited first!");
20138 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_is_ok(o);
20139 return nativeResponseValue;
20141 // void CResult_SpliceLockedDecodeErrorZ_free(struct LDKCResult_SpliceLockedDecodeErrorZ _res);
20143 export function CResult_SpliceLockedDecodeErrorZ_free(_res: bigint): void {
20144 if(!isWasmInitialized) {
20145 throw new Error("initializeWasm() must be awaited first!");
20147 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_free(_res);
20148 // debug statements here
20150 // uint64_t CResult_SpliceLockedDecodeErrorZ_clone_ptr(LDKCResult_SpliceLockedDecodeErrorZ *NONNULL_PTR arg);
20152 export function CResult_SpliceLockedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20153 if(!isWasmInitialized) {
20154 throw new Error("initializeWasm() must be awaited first!");
20156 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_clone_ptr(arg);
20157 return nativeResponseValue;
20159 // struct LDKCResult_SpliceLockedDecodeErrorZ CResult_SpliceLockedDecodeErrorZ_clone(const struct LDKCResult_SpliceLockedDecodeErrorZ *NONNULL_PTR orig);
20161 export function CResult_SpliceLockedDecodeErrorZ_clone(orig: bigint): bigint {
20162 if(!isWasmInitialized) {
20163 throw new Error("initializeWasm() must be awaited first!");
20165 const nativeResponseValue = wasm.TS_CResult_SpliceLockedDecodeErrorZ_clone(orig);
20166 return nativeResponseValue;
20168 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_ok(struct LDKTxAddInput o);
20170 export function CResult_TxAddInputDecodeErrorZ_ok(o: bigint): bigint {
20171 if(!isWasmInitialized) {
20172 throw new Error("initializeWasm() must be awaited first!");
20174 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_ok(o);
20175 return nativeResponseValue;
20177 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_err(struct LDKDecodeError e);
20179 export function CResult_TxAddInputDecodeErrorZ_err(e: bigint): bigint {
20180 if(!isWasmInitialized) {
20181 throw new Error("initializeWasm() must be awaited first!");
20183 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_err(e);
20184 return nativeResponseValue;
20186 // bool CResult_TxAddInputDecodeErrorZ_is_ok(const struct LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR o);
20188 export function CResult_TxAddInputDecodeErrorZ_is_ok(o: bigint): boolean {
20189 if(!isWasmInitialized) {
20190 throw new Error("initializeWasm() must be awaited first!");
20192 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_is_ok(o);
20193 return nativeResponseValue;
20195 // void CResult_TxAddInputDecodeErrorZ_free(struct LDKCResult_TxAddInputDecodeErrorZ _res);
20197 export function CResult_TxAddInputDecodeErrorZ_free(_res: bigint): void {
20198 if(!isWasmInitialized) {
20199 throw new Error("initializeWasm() must be awaited first!");
20201 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_free(_res);
20202 // debug statements here
20204 // uint64_t CResult_TxAddInputDecodeErrorZ_clone_ptr(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR arg);
20206 export function CResult_TxAddInputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20207 if(!isWasmInitialized) {
20208 throw new Error("initializeWasm() must be awaited first!");
20210 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_clone_ptr(arg);
20211 return nativeResponseValue;
20213 // struct LDKCResult_TxAddInputDecodeErrorZ CResult_TxAddInputDecodeErrorZ_clone(const struct LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR orig);
20215 export function CResult_TxAddInputDecodeErrorZ_clone(orig: bigint): bigint {
20216 if(!isWasmInitialized) {
20217 throw new Error("initializeWasm() must be awaited first!");
20219 const nativeResponseValue = wasm.TS_CResult_TxAddInputDecodeErrorZ_clone(orig);
20220 return nativeResponseValue;
20222 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_ok(struct LDKTxAddOutput o);
20224 export function CResult_TxAddOutputDecodeErrorZ_ok(o: bigint): bigint {
20225 if(!isWasmInitialized) {
20226 throw new Error("initializeWasm() must be awaited first!");
20228 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_ok(o);
20229 return nativeResponseValue;
20231 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_err(struct LDKDecodeError e);
20233 export function CResult_TxAddOutputDecodeErrorZ_err(e: bigint): bigint {
20234 if(!isWasmInitialized) {
20235 throw new Error("initializeWasm() must be awaited first!");
20237 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_err(e);
20238 return nativeResponseValue;
20240 // bool CResult_TxAddOutputDecodeErrorZ_is_ok(const struct LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR o);
20242 export function CResult_TxAddOutputDecodeErrorZ_is_ok(o: bigint): boolean {
20243 if(!isWasmInitialized) {
20244 throw new Error("initializeWasm() must be awaited first!");
20246 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_is_ok(o);
20247 return nativeResponseValue;
20249 // void CResult_TxAddOutputDecodeErrorZ_free(struct LDKCResult_TxAddOutputDecodeErrorZ _res);
20251 export function CResult_TxAddOutputDecodeErrorZ_free(_res: bigint): void {
20252 if(!isWasmInitialized) {
20253 throw new Error("initializeWasm() must be awaited first!");
20255 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_free(_res);
20256 // debug statements here
20258 // uint64_t CResult_TxAddOutputDecodeErrorZ_clone_ptr(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR arg);
20260 export function CResult_TxAddOutputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20261 if(!isWasmInitialized) {
20262 throw new Error("initializeWasm() must be awaited first!");
20264 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_clone_ptr(arg);
20265 return nativeResponseValue;
20267 // struct LDKCResult_TxAddOutputDecodeErrorZ CResult_TxAddOutputDecodeErrorZ_clone(const struct LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR orig);
20269 export function CResult_TxAddOutputDecodeErrorZ_clone(orig: bigint): bigint {
20270 if(!isWasmInitialized) {
20271 throw new Error("initializeWasm() must be awaited first!");
20273 const nativeResponseValue = wasm.TS_CResult_TxAddOutputDecodeErrorZ_clone(orig);
20274 return nativeResponseValue;
20276 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_ok(struct LDKTxRemoveInput o);
20278 export function CResult_TxRemoveInputDecodeErrorZ_ok(o: bigint): bigint {
20279 if(!isWasmInitialized) {
20280 throw new Error("initializeWasm() must be awaited first!");
20282 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_ok(o);
20283 return nativeResponseValue;
20285 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_err(struct LDKDecodeError e);
20287 export function CResult_TxRemoveInputDecodeErrorZ_err(e: bigint): bigint {
20288 if(!isWasmInitialized) {
20289 throw new Error("initializeWasm() must be awaited first!");
20291 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_err(e);
20292 return nativeResponseValue;
20294 // bool CResult_TxRemoveInputDecodeErrorZ_is_ok(const struct LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR o);
20296 export function CResult_TxRemoveInputDecodeErrorZ_is_ok(o: bigint): boolean {
20297 if(!isWasmInitialized) {
20298 throw new Error("initializeWasm() must be awaited first!");
20300 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_is_ok(o);
20301 return nativeResponseValue;
20303 // void CResult_TxRemoveInputDecodeErrorZ_free(struct LDKCResult_TxRemoveInputDecodeErrorZ _res);
20305 export function CResult_TxRemoveInputDecodeErrorZ_free(_res: bigint): void {
20306 if(!isWasmInitialized) {
20307 throw new Error("initializeWasm() must be awaited first!");
20309 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_free(_res);
20310 // debug statements here
20312 // uint64_t CResult_TxRemoveInputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR arg);
20314 export function CResult_TxRemoveInputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20315 if(!isWasmInitialized) {
20316 throw new Error("initializeWasm() must be awaited first!");
20318 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_clone_ptr(arg);
20319 return nativeResponseValue;
20321 // struct LDKCResult_TxRemoveInputDecodeErrorZ CResult_TxRemoveInputDecodeErrorZ_clone(const struct LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR orig);
20323 export function CResult_TxRemoveInputDecodeErrorZ_clone(orig: bigint): bigint {
20324 if(!isWasmInitialized) {
20325 throw new Error("initializeWasm() must be awaited first!");
20327 const nativeResponseValue = wasm.TS_CResult_TxRemoveInputDecodeErrorZ_clone(orig);
20328 return nativeResponseValue;
20330 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_ok(struct LDKTxRemoveOutput o);
20332 export function CResult_TxRemoveOutputDecodeErrorZ_ok(o: bigint): bigint {
20333 if(!isWasmInitialized) {
20334 throw new Error("initializeWasm() must be awaited first!");
20336 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_ok(o);
20337 return nativeResponseValue;
20339 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_err(struct LDKDecodeError e);
20341 export function CResult_TxRemoveOutputDecodeErrorZ_err(e: bigint): bigint {
20342 if(!isWasmInitialized) {
20343 throw new Error("initializeWasm() must be awaited first!");
20345 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_err(e);
20346 return nativeResponseValue;
20348 // bool CResult_TxRemoveOutputDecodeErrorZ_is_ok(const struct LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR o);
20350 export function CResult_TxRemoveOutputDecodeErrorZ_is_ok(o: bigint): boolean {
20351 if(!isWasmInitialized) {
20352 throw new Error("initializeWasm() must be awaited first!");
20354 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_is_ok(o);
20355 return nativeResponseValue;
20357 // void CResult_TxRemoveOutputDecodeErrorZ_free(struct LDKCResult_TxRemoveOutputDecodeErrorZ _res);
20359 export function CResult_TxRemoveOutputDecodeErrorZ_free(_res: bigint): void {
20360 if(!isWasmInitialized) {
20361 throw new Error("initializeWasm() must be awaited first!");
20363 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_free(_res);
20364 // debug statements here
20366 // uint64_t CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR arg);
20368 export function CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20369 if(!isWasmInitialized) {
20370 throw new Error("initializeWasm() must be awaited first!");
20372 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(arg);
20373 return nativeResponseValue;
20375 // struct LDKCResult_TxRemoveOutputDecodeErrorZ CResult_TxRemoveOutputDecodeErrorZ_clone(const struct LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR orig);
20377 export function CResult_TxRemoveOutputDecodeErrorZ_clone(orig: bigint): bigint {
20378 if(!isWasmInitialized) {
20379 throw new Error("initializeWasm() must be awaited first!");
20381 const nativeResponseValue = wasm.TS_CResult_TxRemoveOutputDecodeErrorZ_clone(orig);
20382 return nativeResponseValue;
20384 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_ok(struct LDKTxComplete o);
20386 export function CResult_TxCompleteDecodeErrorZ_ok(o: bigint): bigint {
20387 if(!isWasmInitialized) {
20388 throw new Error("initializeWasm() must be awaited first!");
20390 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_ok(o);
20391 return nativeResponseValue;
20393 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_err(struct LDKDecodeError e);
20395 export function CResult_TxCompleteDecodeErrorZ_err(e: bigint): bigint {
20396 if(!isWasmInitialized) {
20397 throw new Error("initializeWasm() must be awaited first!");
20399 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_err(e);
20400 return nativeResponseValue;
20402 // bool CResult_TxCompleteDecodeErrorZ_is_ok(const struct LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR o);
20404 export function CResult_TxCompleteDecodeErrorZ_is_ok(o: bigint): boolean {
20405 if(!isWasmInitialized) {
20406 throw new Error("initializeWasm() must be awaited first!");
20408 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_is_ok(o);
20409 return nativeResponseValue;
20411 // void CResult_TxCompleteDecodeErrorZ_free(struct LDKCResult_TxCompleteDecodeErrorZ _res);
20413 export function CResult_TxCompleteDecodeErrorZ_free(_res: bigint): void {
20414 if(!isWasmInitialized) {
20415 throw new Error("initializeWasm() must be awaited first!");
20417 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_free(_res);
20418 // debug statements here
20420 // uint64_t CResult_TxCompleteDecodeErrorZ_clone_ptr(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR arg);
20422 export function CResult_TxCompleteDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20423 if(!isWasmInitialized) {
20424 throw new Error("initializeWasm() must be awaited first!");
20426 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_clone_ptr(arg);
20427 return nativeResponseValue;
20429 // struct LDKCResult_TxCompleteDecodeErrorZ CResult_TxCompleteDecodeErrorZ_clone(const struct LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR orig);
20431 export function CResult_TxCompleteDecodeErrorZ_clone(orig: bigint): bigint {
20432 if(!isWasmInitialized) {
20433 throw new Error("initializeWasm() must be awaited first!");
20435 const nativeResponseValue = wasm.TS_CResult_TxCompleteDecodeErrorZ_clone(orig);
20436 return nativeResponseValue;
20438 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_ok(struct LDKTxSignatures o);
20440 export function CResult_TxSignaturesDecodeErrorZ_ok(o: bigint): bigint {
20441 if(!isWasmInitialized) {
20442 throw new Error("initializeWasm() must be awaited first!");
20444 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_ok(o);
20445 return nativeResponseValue;
20447 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
20449 export function CResult_TxSignaturesDecodeErrorZ_err(e: bigint): bigint {
20450 if(!isWasmInitialized) {
20451 throw new Error("initializeWasm() must be awaited first!");
20453 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_err(e);
20454 return nativeResponseValue;
20456 // bool CResult_TxSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR o);
20458 export function CResult_TxSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
20459 if(!isWasmInitialized) {
20460 throw new Error("initializeWasm() must be awaited first!");
20462 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_is_ok(o);
20463 return nativeResponseValue;
20465 // void CResult_TxSignaturesDecodeErrorZ_free(struct LDKCResult_TxSignaturesDecodeErrorZ _res);
20467 export function CResult_TxSignaturesDecodeErrorZ_free(_res: bigint): void {
20468 if(!isWasmInitialized) {
20469 throw new Error("initializeWasm() must be awaited first!");
20471 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_free(_res);
20472 // debug statements here
20474 // uint64_t CResult_TxSignaturesDecodeErrorZ_clone_ptr(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR arg);
20476 export function CResult_TxSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20477 if(!isWasmInitialized) {
20478 throw new Error("initializeWasm() must be awaited first!");
20480 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_clone_ptr(arg);
20481 return nativeResponseValue;
20483 // struct LDKCResult_TxSignaturesDecodeErrorZ CResult_TxSignaturesDecodeErrorZ_clone(const struct LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR orig);
20485 export function CResult_TxSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
20486 if(!isWasmInitialized) {
20487 throw new Error("initializeWasm() must be awaited first!");
20489 const nativeResponseValue = wasm.TS_CResult_TxSignaturesDecodeErrorZ_clone(orig);
20490 return nativeResponseValue;
20492 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_ok(struct LDKTxInitRbf o);
20494 export function CResult_TxInitRbfDecodeErrorZ_ok(o: bigint): bigint {
20495 if(!isWasmInitialized) {
20496 throw new Error("initializeWasm() must be awaited first!");
20498 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_ok(o);
20499 return nativeResponseValue;
20501 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_err(struct LDKDecodeError e);
20503 export function CResult_TxInitRbfDecodeErrorZ_err(e: bigint): bigint {
20504 if(!isWasmInitialized) {
20505 throw new Error("initializeWasm() must be awaited first!");
20507 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_err(e);
20508 return nativeResponseValue;
20510 // bool CResult_TxInitRbfDecodeErrorZ_is_ok(const struct LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR o);
20512 export function CResult_TxInitRbfDecodeErrorZ_is_ok(o: bigint): boolean {
20513 if(!isWasmInitialized) {
20514 throw new Error("initializeWasm() must be awaited first!");
20516 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_is_ok(o);
20517 return nativeResponseValue;
20519 // void CResult_TxInitRbfDecodeErrorZ_free(struct LDKCResult_TxInitRbfDecodeErrorZ _res);
20521 export function CResult_TxInitRbfDecodeErrorZ_free(_res: bigint): void {
20522 if(!isWasmInitialized) {
20523 throw new Error("initializeWasm() must be awaited first!");
20525 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_free(_res);
20526 // debug statements here
20528 // uint64_t CResult_TxInitRbfDecodeErrorZ_clone_ptr(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR arg);
20530 export function CResult_TxInitRbfDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20531 if(!isWasmInitialized) {
20532 throw new Error("initializeWasm() must be awaited first!");
20534 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_clone_ptr(arg);
20535 return nativeResponseValue;
20537 // struct LDKCResult_TxInitRbfDecodeErrorZ CResult_TxInitRbfDecodeErrorZ_clone(const struct LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR orig);
20539 export function CResult_TxInitRbfDecodeErrorZ_clone(orig: bigint): bigint {
20540 if(!isWasmInitialized) {
20541 throw new Error("initializeWasm() must be awaited first!");
20543 const nativeResponseValue = wasm.TS_CResult_TxInitRbfDecodeErrorZ_clone(orig);
20544 return nativeResponseValue;
20546 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_ok(struct LDKTxAckRbf o);
20548 export function CResult_TxAckRbfDecodeErrorZ_ok(o: bigint): bigint {
20549 if(!isWasmInitialized) {
20550 throw new Error("initializeWasm() must be awaited first!");
20552 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_ok(o);
20553 return nativeResponseValue;
20555 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_err(struct LDKDecodeError e);
20557 export function CResult_TxAckRbfDecodeErrorZ_err(e: bigint): bigint {
20558 if(!isWasmInitialized) {
20559 throw new Error("initializeWasm() must be awaited first!");
20561 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_err(e);
20562 return nativeResponseValue;
20564 // bool CResult_TxAckRbfDecodeErrorZ_is_ok(const struct LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR o);
20566 export function CResult_TxAckRbfDecodeErrorZ_is_ok(o: bigint): boolean {
20567 if(!isWasmInitialized) {
20568 throw new Error("initializeWasm() must be awaited first!");
20570 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_is_ok(o);
20571 return nativeResponseValue;
20573 // void CResult_TxAckRbfDecodeErrorZ_free(struct LDKCResult_TxAckRbfDecodeErrorZ _res);
20575 export function CResult_TxAckRbfDecodeErrorZ_free(_res: bigint): void {
20576 if(!isWasmInitialized) {
20577 throw new Error("initializeWasm() must be awaited first!");
20579 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_free(_res);
20580 // debug statements here
20582 // uint64_t CResult_TxAckRbfDecodeErrorZ_clone_ptr(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR arg);
20584 export function CResult_TxAckRbfDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20585 if(!isWasmInitialized) {
20586 throw new Error("initializeWasm() must be awaited first!");
20588 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_clone_ptr(arg);
20589 return nativeResponseValue;
20591 // struct LDKCResult_TxAckRbfDecodeErrorZ CResult_TxAckRbfDecodeErrorZ_clone(const struct LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR orig);
20593 export function CResult_TxAckRbfDecodeErrorZ_clone(orig: bigint): bigint {
20594 if(!isWasmInitialized) {
20595 throw new Error("initializeWasm() must be awaited first!");
20597 const nativeResponseValue = wasm.TS_CResult_TxAckRbfDecodeErrorZ_clone(orig);
20598 return nativeResponseValue;
20600 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_ok(struct LDKTxAbort o);
20602 export function CResult_TxAbortDecodeErrorZ_ok(o: bigint): bigint {
20603 if(!isWasmInitialized) {
20604 throw new Error("initializeWasm() must be awaited first!");
20606 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_ok(o);
20607 return nativeResponseValue;
20609 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_err(struct LDKDecodeError e);
20611 export function CResult_TxAbortDecodeErrorZ_err(e: bigint): bigint {
20612 if(!isWasmInitialized) {
20613 throw new Error("initializeWasm() must be awaited first!");
20615 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_err(e);
20616 return nativeResponseValue;
20618 // bool CResult_TxAbortDecodeErrorZ_is_ok(const struct LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR o);
20620 export function CResult_TxAbortDecodeErrorZ_is_ok(o: bigint): boolean {
20621 if(!isWasmInitialized) {
20622 throw new Error("initializeWasm() must be awaited first!");
20624 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_is_ok(o);
20625 return nativeResponseValue;
20627 // void CResult_TxAbortDecodeErrorZ_free(struct LDKCResult_TxAbortDecodeErrorZ _res);
20629 export function CResult_TxAbortDecodeErrorZ_free(_res: bigint): void {
20630 if(!isWasmInitialized) {
20631 throw new Error("initializeWasm() must be awaited first!");
20633 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_free(_res);
20634 // debug statements here
20636 // uint64_t CResult_TxAbortDecodeErrorZ_clone_ptr(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR arg);
20638 export function CResult_TxAbortDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20639 if(!isWasmInitialized) {
20640 throw new Error("initializeWasm() must be awaited first!");
20642 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_clone_ptr(arg);
20643 return nativeResponseValue;
20645 // struct LDKCResult_TxAbortDecodeErrorZ CResult_TxAbortDecodeErrorZ_clone(const struct LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR orig);
20647 export function CResult_TxAbortDecodeErrorZ_clone(orig: bigint): bigint {
20648 if(!isWasmInitialized) {
20649 throw new Error("initializeWasm() must be awaited first!");
20651 const nativeResponseValue = wasm.TS_CResult_TxAbortDecodeErrorZ_clone(orig);
20652 return nativeResponseValue;
20654 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
20656 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: bigint): bigint {
20657 if(!isWasmInitialized) {
20658 throw new Error("initializeWasm() must be awaited first!");
20660 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
20661 return nativeResponseValue;
20663 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
20665 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: bigint): bigint {
20666 if(!isWasmInitialized) {
20667 throw new Error("initializeWasm() must be awaited first!");
20669 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
20670 return nativeResponseValue;
20672 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
20674 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: bigint): boolean {
20675 if(!isWasmInitialized) {
20676 throw new Error("initializeWasm() must be awaited first!");
20678 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
20679 return nativeResponseValue;
20681 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
20683 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: bigint): void {
20684 if(!isWasmInitialized) {
20685 throw new Error("initializeWasm() must be awaited first!");
20687 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
20688 // debug statements here
20690 // uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
20692 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20693 if(!isWasmInitialized) {
20694 throw new Error("initializeWasm() must be awaited first!");
20696 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
20697 return nativeResponseValue;
20699 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
20701 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: bigint): bigint {
20702 if(!isWasmInitialized) {
20703 throw new Error("initializeWasm() must be awaited first!");
20705 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
20706 return nativeResponseValue;
20708 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
20710 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: bigint): bigint {
20711 if(!isWasmInitialized) {
20712 throw new Error("initializeWasm() must be awaited first!");
20714 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
20715 return nativeResponseValue;
20717 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
20719 export function CResult_ChannelReestablishDecodeErrorZ_err(e: bigint): bigint {
20720 if(!isWasmInitialized) {
20721 throw new Error("initializeWasm() must be awaited first!");
20723 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
20724 return nativeResponseValue;
20726 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
20728 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: bigint): boolean {
20729 if(!isWasmInitialized) {
20730 throw new Error("initializeWasm() must be awaited first!");
20732 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
20733 return nativeResponseValue;
20735 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
20737 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: bigint): void {
20738 if(!isWasmInitialized) {
20739 throw new Error("initializeWasm() must be awaited first!");
20741 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
20742 // debug statements here
20744 // uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
20746 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20747 if(!isWasmInitialized) {
20748 throw new Error("initializeWasm() must be awaited first!");
20750 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
20751 return nativeResponseValue;
20753 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
20755 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: bigint): bigint {
20756 if(!isWasmInitialized) {
20757 throw new Error("initializeWasm() must be awaited first!");
20759 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
20760 return nativeResponseValue;
20762 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
20764 export function CResult_ClosingSignedDecodeErrorZ_ok(o: bigint): bigint {
20765 if(!isWasmInitialized) {
20766 throw new Error("initializeWasm() must be awaited first!");
20768 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
20769 return nativeResponseValue;
20771 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
20773 export function CResult_ClosingSignedDecodeErrorZ_err(e: bigint): bigint {
20774 if(!isWasmInitialized) {
20775 throw new Error("initializeWasm() must be awaited first!");
20777 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
20778 return nativeResponseValue;
20780 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
20782 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
20783 if(!isWasmInitialized) {
20784 throw new Error("initializeWasm() must be awaited first!");
20786 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
20787 return nativeResponseValue;
20789 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
20791 export function CResult_ClosingSignedDecodeErrorZ_free(_res: bigint): void {
20792 if(!isWasmInitialized) {
20793 throw new Error("initializeWasm() must be awaited first!");
20795 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
20796 // debug statements here
20798 // uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
20800 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20801 if(!isWasmInitialized) {
20802 throw new Error("initializeWasm() must be awaited first!");
20804 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
20805 return nativeResponseValue;
20807 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
20809 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: bigint): bigint {
20810 if(!isWasmInitialized) {
20811 throw new Error("initializeWasm() must be awaited first!");
20813 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
20814 return nativeResponseValue;
20816 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
20818 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: bigint): bigint {
20819 if(!isWasmInitialized) {
20820 throw new Error("initializeWasm() must be awaited first!");
20822 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
20823 return nativeResponseValue;
20825 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
20827 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: bigint): bigint {
20828 if(!isWasmInitialized) {
20829 throw new Error("initializeWasm() must be awaited first!");
20831 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
20832 return nativeResponseValue;
20834 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
20836 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: bigint): boolean {
20837 if(!isWasmInitialized) {
20838 throw new Error("initializeWasm() must be awaited first!");
20840 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
20841 return nativeResponseValue;
20843 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
20845 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: bigint): void {
20846 if(!isWasmInitialized) {
20847 throw new Error("initializeWasm() must be awaited first!");
20849 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
20850 // debug statements here
20852 // uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
20854 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20855 if(!isWasmInitialized) {
20856 throw new Error("initializeWasm() must be awaited first!");
20858 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
20859 return nativeResponseValue;
20861 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
20863 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: bigint): bigint {
20864 if(!isWasmInitialized) {
20865 throw new Error("initializeWasm() must be awaited first!");
20867 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
20868 return nativeResponseValue;
20870 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
20872 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: bigint): bigint {
20873 if(!isWasmInitialized) {
20874 throw new Error("initializeWasm() must be awaited first!");
20876 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
20877 return nativeResponseValue;
20879 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
20881 export function CResult_CommitmentSignedDecodeErrorZ_err(e: bigint): bigint {
20882 if(!isWasmInitialized) {
20883 throw new Error("initializeWasm() must be awaited first!");
20885 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
20886 return nativeResponseValue;
20888 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
20890 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: bigint): boolean {
20891 if(!isWasmInitialized) {
20892 throw new Error("initializeWasm() must be awaited first!");
20894 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
20895 return nativeResponseValue;
20897 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
20899 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: bigint): void {
20900 if(!isWasmInitialized) {
20901 throw new Error("initializeWasm() must be awaited first!");
20903 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
20904 // debug statements here
20906 // uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
20908 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20909 if(!isWasmInitialized) {
20910 throw new Error("initializeWasm() must be awaited first!");
20912 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
20913 return nativeResponseValue;
20915 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
20917 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: bigint): bigint {
20918 if(!isWasmInitialized) {
20919 throw new Error("initializeWasm() must be awaited first!");
20921 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
20922 return nativeResponseValue;
20924 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
20926 export function CResult_FundingCreatedDecodeErrorZ_ok(o: bigint): bigint {
20927 if(!isWasmInitialized) {
20928 throw new Error("initializeWasm() must be awaited first!");
20930 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
20931 return nativeResponseValue;
20933 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
20935 export function CResult_FundingCreatedDecodeErrorZ_err(e: bigint): bigint {
20936 if(!isWasmInitialized) {
20937 throw new Error("initializeWasm() must be awaited first!");
20939 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
20940 return nativeResponseValue;
20942 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
20944 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: bigint): boolean {
20945 if(!isWasmInitialized) {
20946 throw new Error("initializeWasm() must be awaited first!");
20948 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
20949 return nativeResponseValue;
20951 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
20953 export function CResult_FundingCreatedDecodeErrorZ_free(_res: bigint): void {
20954 if(!isWasmInitialized) {
20955 throw new Error("initializeWasm() must be awaited first!");
20957 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
20958 // debug statements here
20960 // uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
20962 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
20963 if(!isWasmInitialized) {
20964 throw new Error("initializeWasm() must be awaited first!");
20966 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
20967 return nativeResponseValue;
20969 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
20971 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: bigint): bigint {
20972 if(!isWasmInitialized) {
20973 throw new Error("initializeWasm() must be awaited first!");
20975 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
20976 return nativeResponseValue;
20978 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
20980 export function CResult_FundingSignedDecodeErrorZ_ok(o: bigint): bigint {
20981 if(!isWasmInitialized) {
20982 throw new Error("initializeWasm() must be awaited first!");
20984 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
20985 return nativeResponseValue;
20987 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
20989 export function CResult_FundingSignedDecodeErrorZ_err(e: bigint): bigint {
20990 if(!isWasmInitialized) {
20991 throw new Error("initializeWasm() must be awaited first!");
20993 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
20994 return nativeResponseValue;
20996 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
20998 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: bigint): boolean {
20999 if(!isWasmInitialized) {
21000 throw new Error("initializeWasm() must be awaited first!");
21002 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
21003 return nativeResponseValue;
21005 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
21007 export function CResult_FundingSignedDecodeErrorZ_free(_res: bigint): void {
21008 if(!isWasmInitialized) {
21009 throw new Error("initializeWasm() must be awaited first!");
21011 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
21012 // debug statements here
21014 // uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
21016 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21017 if(!isWasmInitialized) {
21018 throw new Error("initializeWasm() must be awaited first!");
21020 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
21021 return nativeResponseValue;
21023 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
21025 export function CResult_FundingSignedDecodeErrorZ_clone(orig: bigint): bigint {
21026 if(!isWasmInitialized) {
21027 throw new Error("initializeWasm() must be awaited first!");
21029 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
21030 return nativeResponseValue;
21032 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
21034 export function CResult_ChannelReadyDecodeErrorZ_ok(o: bigint): bigint {
21035 if(!isWasmInitialized) {
21036 throw new Error("initializeWasm() must be awaited first!");
21038 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
21039 return nativeResponseValue;
21041 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
21043 export function CResult_ChannelReadyDecodeErrorZ_err(e: bigint): bigint {
21044 if(!isWasmInitialized) {
21045 throw new Error("initializeWasm() must be awaited first!");
21047 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
21048 return nativeResponseValue;
21050 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
21052 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: bigint): boolean {
21053 if(!isWasmInitialized) {
21054 throw new Error("initializeWasm() must be awaited first!");
21056 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
21057 return nativeResponseValue;
21059 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
21061 export function CResult_ChannelReadyDecodeErrorZ_free(_res: bigint): void {
21062 if(!isWasmInitialized) {
21063 throw new Error("initializeWasm() must be awaited first!");
21065 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
21066 // debug statements here
21068 // uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
21070 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21071 if(!isWasmInitialized) {
21072 throw new Error("initializeWasm() must be awaited first!");
21074 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
21075 return nativeResponseValue;
21077 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
21079 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: bigint): bigint {
21080 if(!isWasmInitialized) {
21081 throw new Error("initializeWasm() must be awaited first!");
21083 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
21084 return nativeResponseValue;
21086 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
21088 export function CResult_InitDecodeErrorZ_ok(o: bigint): bigint {
21089 if(!isWasmInitialized) {
21090 throw new Error("initializeWasm() must be awaited first!");
21092 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
21093 return nativeResponseValue;
21095 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
21097 export function CResult_InitDecodeErrorZ_err(e: bigint): bigint {
21098 if(!isWasmInitialized) {
21099 throw new Error("initializeWasm() must be awaited first!");
21101 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
21102 return nativeResponseValue;
21104 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
21106 export function CResult_InitDecodeErrorZ_is_ok(o: bigint): boolean {
21107 if(!isWasmInitialized) {
21108 throw new Error("initializeWasm() must be awaited first!");
21110 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
21111 return nativeResponseValue;
21113 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
21115 export function CResult_InitDecodeErrorZ_free(_res: bigint): void {
21116 if(!isWasmInitialized) {
21117 throw new Error("initializeWasm() must be awaited first!");
21119 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
21120 // debug statements here
21122 // uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
21124 export function CResult_InitDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21125 if(!isWasmInitialized) {
21126 throw new Error("initializeWasm() must be awaited first!");
21128 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
21129 return nativeResponseValue;
21131 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
21133 export function CResult_InitDecodeErrorZ_clone(orig: bigint): bigint {
21134 if(!isWasmInitialized) {
21135 throw new Error("initializeWasm() must be awaited first!");
21137 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
21138 return nativeResponseValue;
21140 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
21142 export function CResult_OpenChannelDecodeErrorZ_ok(o: bigint): bigint {
21143 if(!isWasmInitialized) {
21144 throw new Error("initializeWasm() must be awaited first!");
21146 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
21147 return nativeResponseValue;
21149 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
21151 export function CResult_OpenChannelDecodeErrorZ_err(e: bigint): bigint {
21152 if(!isWasmInitialized) {
21153 throw new Error("initializeWasm() must be awaited first!");
21155 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
21156 return nativeResponseValue;
21158 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
21160 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: bigint): boolean {
21161 if(!isWasmInitialized) {
21162 throw new Error("initializeWasm() must be awaited first!");
21164 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
21165 return nativeResponseValue;
21167 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
21169 export function CResult_OpenChannelDecodeErrorZ_free(_res: bigint): void {
21170 if(!isWasmInitialized) {
21171 throw new Error("initializeWasm() must be awaited first!");
21173 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
21174 // debug statements here
21176 // uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
21178 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21179 if(!isWasmInitialized) {
21180 throw new Error("initializeWasm() must be awaited first!");
21182 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
21183 return nativeResponseValue;
21185 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
21187 export function CResult_OpenChannelDecodeErrorZ_clone(orig: bigint): bigint {
21188 if(!isWasmInitialized) {
21189 throw new Error("initializeWasm() must be awaited first!");
21191 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
21192 return nativeResponseValue;
21194 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_ok(struct LDKOpenChannelV2 o);
21196 export function CResult_OpenChannelV2DecodeErrorZ_ok(o: bigint): bigint {
21197 if(!isWasmInitialized) {
21198 throw new Error("initializeWasm() must be awaited first!");
21200 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_ok(o);
21201 return nativeResponseValue;
21203 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_err(struct LDKDecodeError e);
21205 export function CResult_OpenChannelV2DecodeErrorZ_err(e: bigint): bigint {
21206 if(!isWasmInitialized) {
21207 throw new Error("initializeWasm() must be awaited first!");
21209 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_err(e);
21210 return nativeResponseValue;
21212 // bool CResult_OpenChannelV2DecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR o);
21214 export function CResult_OpenChannelV2DecodeErrorZ_is_ok(o: bigint): boolean {
21215 if(!isWasmInitialized) {
21216 throw new Error("initializeWasm() must be awaited first!");
21218 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_is_ok(o);
21219 return nativeResponseValue;
21221 // void CResult_OpenChannelV2DecodeErrorZ_free(struct LDKCResult_OpenChannelV2DecodeErrorZ _res);
21223 export function CResult_OpenChannelV2DecodeErrorZ_free(_res: bigint): void {
21224 if(!isWasmInitialized) {
21225 throw new Error("initializeWasm() must be awaited first!");
21227 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_free(_res);
21228 // debug statements here
21230 // uint64_t CResult_OpenChannelV2DecodeErrorZ_clone_ptr(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR arg);
21232 export function CResult_OpenChannelV2DecodeErrorZ_clone_ptr(arg: bigint): bigint {
21233 if(!isWasmInitialized) {
21234 throw new Error("initializeWasm() must be awaited first!");
21236 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_clone_ptr(arg);
21237 return nativeResponseValue;
21239 // struct LDKCResult_OpenChannelV2DecodeErrorZ CResult_OpenChannelV2DecodeErrorZ_clone(const struct LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR orig);
21241 export function CResult_OpenChannelV2DecodeErrorZ_clone(orig: bigint): bigint {
21242 if(!isWasmInitialized) {
21243 throw new Error("initializeWasm() must be awaited first!");
21245 const nativeResponseValue = wasm.TS_CResult_OpenChannelV2DecodeErrorZ_clone(orig);
21246 return nativeResponseValue;
21248 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
21250 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: bigint): bigint {
21251 if(!isWasmInitialized) {
21252 throw new Error("initializeWasm() must be awaited first!");
21254 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
21255 return nativeResponseValue;
21257 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
21259 export function CResult_RevokeAndACKDecodeErrorZ_err(e: bigint): bigint {
21260 if(!isWasmInitialized) {
21261 throw new Error("initializeWasm() must be awaited first!");
21263 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
21264 return nativeResponseValue;
21266 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
21268 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: bigint): boolean {
21269 if(!isWasmInitialized) {
21270 throw new Error("initializeWasm() must be awaited first!");
21272 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
21273 return nativeResponseValue;
21275 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
21277 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: bigint): void {
21278 if(!isWasmInitialized) {
21279 throw new Error("initializeWasm() must be awaited first!");
21281 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
21282 // debug statements here
21284 // uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
21286 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21287 if(!isWasmInitialized) {
21288 throw new Error("initializeWasm() must be awaited first!");
21290 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
21291 return nativeResponseValue;
21293 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
21295 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: bigint): bigint {
21296 if(!isWasmInitialized) {
21297 throw new Error("initializeWasm() must be awaited first!");
21299 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
21300 return nativeResponseValue;
21302 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
21304 export function CResult_ShutdownDecodeErrorZ_ok(o: bigint): bigint {
21305 if(!isWasmInitialized) {
21306 throw new Error("initializeWasm() must be awaited first!");
21308 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
21309 return nativeResponseValue;
21311 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
21313 export function CResult_ShutdownDecodeErrorZ_err(e: bigint): bigint {
21314 if(!isWasmInitialized) {
21315 throw new Error("initializeWasm() must be awaited first!");
21317 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
21318 return nativeResponseValue;
21320 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
21322 export function CResult_ShutdownDecodeErrorZ_is_ok(o: bigint): boolean {
21323 if(!isWasmInitialized) {
21324 throw new Error("initializeWasm() must be awaited first!");
21326 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
21327 return nativeResponseValue;
21329 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
21331 export function CResult_ShutdownDecodeErrorZ_free(_res: bigint): void {
21332 if(!isWasmInitialized) {
21333 throw new Error("initializeWasm() must be awaited first!");
21335 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
21336 // debug statements here
21338 // uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
21340 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21341 if(!isWasmInitialized) {
21342 throw new Error("initializeWasm() must be awaited first!");
21344 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
21345 return nativeResponseValue;
21347 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
21349 export function CResult_ShutdownDecodeErrorZ_clone(orig: bigint): bigint {
21350 if(!isWasmInitialized) {
21351 throw new Error("initializeWasm() must be awaited first!");
21353 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
21354 return nativeResponseValue;
21356 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
21358 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: bigint): bigint {
21359 if(!isWasmInitialized) {
21360 throw new Error("initializeWasm() must be awaited first!");
21362 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
21363 return nativeResponseValue;
21365 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
21367 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: bigint): bigint {
21368 if(!isWasmInitialized) {
21369 throw new Error("initializeWasm() must be awaited first!");
21371 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
21372 return nativeResponseValue;
21374 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
21376 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
21377 if(!isWasmInitialized) {
21378 throw new Error("initializeWasm() must be awaited first!");
21380 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
21381 return nativeResponseValue;
21383 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
21385 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: bigint): void {
21386 if(!isWasmInitialized) {
21387 throw new Error("initializeWasm() must be awaited first!");
21389 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
21390 // debug statements here
21392 // uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
21394 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21395 if(!isWasmInitialized) {
21396 throw new Error("initializeWasm() must be awaited first!");
21398 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
21399 return nativeResponseValue;
21401 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
21403 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: bigint): bigint {
21404 if(!isWasmInitialized) {
21405 throw new Error("initializeWasm() must be awaited first!");
21407 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
21408 return nativeResponseValue;
21410 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
21412 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: bigint): bigint {
21413 if(!isWasmInitialized) {
21414 throw new Error("initializeWasm() must be awaited first!");
21416 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
21417 return nativeResponseValue;
21419 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
21421 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: bigint): bigint {
21422 if(!isWasmInitialized) {
21423 throw new Error("initializeWasm() must be awaited first!");
21425 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
21426 return nativeResponseValue;
21428 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
21430 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
21431 if(!isWasmInitialized) {
21432 throw new Error("initializeWasm() must be awaited first!");
21434 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
21435 return nativeResponseValue;
21437 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
21439 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: bigint): void {
21440 if(!isWasmInitialized) {
21441 throw new Error("initializeWasm() must be awaited first!");
21443 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
21444 // debug statements here
21446 // uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
21448 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21449 if(!isWasmInitialized) {
21450 throw new Error("initializeWasm() must be awaited first!");
21452 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
21453 return nativeResponseValue;
21455 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
21457 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
21458 if(!isWasmInitialized) {
21459 throw new Error("initializeWasm() must be awaited first!");
21461 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
21462 return nativeResponseValue;
21464 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
21466 export function CResult_UpdateFeeDecodeErrorZ_ok(o: bigint): bigint {
21467 if(!isWasmInitialized) {
21468 throw new Error("initializeWasm() must be awaited first!");
21470 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
21471 return nativeResponseValue;
21473 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
21475 export function CResult_UpdateFeeDecodeErrorZ_err(e: bigint): bigint {
21476 if(!isWasmInitialized) {
21477 throw new Error("initializeWasm() must be awaited first!");
21479 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
21480 return nativeResponseValue;
21482 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
21484 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: bigint): boolean {
21485 if(!isWasmInitialized) {
21486 throw new Error("initializeWasm() must be awaited first!");
21488 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
21489 return nativeResponseValue;
21491 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
21493 export function CResult_UpdateFeeDecodeErrorZ_free(_res: bigint): void {
21494 if(!isWasmInitialized) {
21495 throw new Error("initializeWasm() must be awaited first!");
21497 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
21498 // debug statements here
21500 // uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
21502 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21503 if(!isWasmInitialized) {
21504 throw new Error("initializeWasm() must be awaited first!");
21506 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
21507 return nativeResponseValue;
21509 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
21511 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: bigint): bigint {
21512 if(!isWasmInitialized) {
21513 throw new Error("initializeWasm() must be awaited first!");
21515 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
21516 return nativeResponseValue;
21518 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
21520 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: bigint): bigint {
21521 if(!isWasmInitialized) {
21522 throw new Error("initializeWasm() must be awaited first!");
21524 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
21525 return nativeResponseValue;
21527 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
21529 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: bigint): bigint {
21530 if(!isWasmInitialized) {
21531 throw new Error("initializeWasm() must be awaited first!");
21533 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
21534 return nativeResponseValue;
21536 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
21538 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
21539 if(!isWasmInitialized) {
21540 throw new Error("initializeWasm() must be awaited first!");
21542 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
21543 return nativeResponseValue;
21545 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
21547 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: bigint): void {
21548 if(!isWasmInitialized) {
21549 throw new Error("initializeWasm() must be awaited first!");
21551 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
21552 // debug statements here
21554 // uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
21556 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21557 if(!isWasmInitialized) {
21558 throw new Error("initializeWasm() must be awaited first!");
21560 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
21561 return nativeResponseValue;
21563 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
21565 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: bigint): bigint {
21566 if(!isWasmInitialized) {
21567 throw new Error("initializeWasm() must be awaited first!");
21569 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
21570 return nativeResponseValue;
21572 // struct LDKCResult_OnionPacketDecodeErrorZ CResult_OnionPacketDecodeErrorZ_ok(struct LDKOnionPacket o);
21574 export function CResult_OnionPacketDecodeErrorZ_ok(o: bigint): bigint {
21575 if(!isWasmInitialized) {
21576 throw new Error("initializeWasm() must be awaited first!");
21578 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_ok(o);
21579 return nativeResponseValue;
21581 // struct LDKCResult_OnionPacketDecodeErrorZ CResult_OnionPacketDecodeErrorZ_err(struct LDKDecodeError e);
21583 export function CResult_OnionPacketDecodeErrorZ_err(e: bigint): bigint {
21584 if(!isWasmInitialized) {
21585 throw new Error("initializeWasm() must be awaited first!");
21587 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_err(e);
21588 return nativeResponseValue;
21590 // bool CResult_OnionPacketDecodeErrorZ_is_ok(const struct LDKCResult_OnionPacketDecodeErrorZ *NONNULL_PTR o);
21592 export function CResult_OnionPacketDecodeErrorZ_is_ok(o: bigint): boolean {
21593 if(!isWasmInitialized) {
21594 throw new Error("initializeWasm() must be awaited first!");
21596 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_is_ok(o);
21597 return nativeResponseValue;
21599 // void CResult_OnionPacketDecodeErrorZ_free(struct LDKCResult_OnionPacketDecodeErrorZ _res);
21601 export function CResult_OnionPacketDecodeErrorZ_free(_res: bigint): void {
21602 if(!isWasmInitialized) {
21603 throw new Error("initializeWasm() must be awaited first!");
21605 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_free(_res);
21606 // debug statements here
21608 // uint64_t CResult_OnionPacketDecodeErrorZ_clone_ptr(LDKCResult_OnionPacketDecodeErrorZ *NONNULL_PTR arg);
21610 export function CResult_OnionPacketDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21611 if(!isWasmInitialized) {
21612 throw new Error("initializeWasm() must be awaited first!");
21614 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_clone_ptr(arg);
21615 return nativeResponseValue;
21617 // struct LDKCResult_OnionPacketDecodeErrorZ CResult_OnionPacketDecodeErrorZ_clone(const struct LDKCResult_OnionPacketDecodeErrorZ *NONNULL_PTR orig);
21619 export function CResult_OnionPacketDecodeErrorZ_clone(orig: bigint): bigint {
21620 if(!isWasmInitialized) {
21621 throw new Error("initializeWasm() must be awaited first!");
21623 const nativeResponseValue = wasm.TS_CResult_OnionPacketDecodeErrorZ_clone(orig);
21624 return nativeResponseValue;
21626 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
21628 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: bigint): bigint {
21629 if(!isWasmInitialized) {
21630 throw new Error("initializeWasm() must be awaited first!");
21632 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
21633 return nativeResponseValue;
21635 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
21637 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: bigint): bigint {
21638 if(!isWasmInitialized) {
21639 throw new Error("initializeWasm() must be awaited first!");
21641 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
21642 return nativeResponseValue;
21644 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
21646 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
21647 if(!isWasmInitialized) {
21648 throw new Error("initializeWasm() must be awaited first!");
21650 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
21651 return nativeResponseValue;
21653 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
21655 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: bigint): void {
21656 if(!isWasmInitialized) {
21657 throw new Error("initializeWasm() must be awaited first!");
21659 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
21660 // debug statements here
21662 // uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
21664 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21665 if(!isWasmInitialized) {
21666 throw new Error("initializeWasm() must be awaited first!");
21668 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
21669 return nativeResponseValue;
21671 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
21673 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: bigint): bigint {
21674 if(!isWasmInitialized) {
21675 throw new Error("initializeWasm() must be awaited first!");
21677 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
21678 return nativeResponseValue;
21680 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_ok(struct LDKOnionMessage o);
21682 export function CResult_OnionMessageDecodeErrorZ_ok(o: bigint): bigint {
21683 if(!isWasmInitialized) {
21684 throw new Error("initializeWasm() must be awaited first!");
21686 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_ok(o);
21687 return nativeResponseValue;
21689 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_err(struct LDKDecodeError e);
21691 export function CResult_OnionMessageDecodeErrorZ_err(e: bigint): bigint {
21692 if(!isWasmInitialized) {
21693 throw new Error("initializeWasm() must be awaited first!");
21695 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_err(e);
21696 return nativeResponseValue;
21698 // bool CResult_OnionMessageDecodeErrorZ_is_ok(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR o);
21700 export function CResult_OnionMessageDecodeErrorZ_is_ok(o: bigint): boolean {
21701 if(!isWasmInitialized) {
21702 throw new Error("initializeWasm() must be awaited first!");
21704 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_is_ok(o);
21705 return nativeResponseValue;
21707 // void CResult_OnionMessageDecodeErrorZ_free(struct LDKCResult_OnionMessageDecodeErrorZ _res);
21709 export function CResult_OnionMessageDecodeErrorZ_free(_res: bigint): void {
21710 if(!isWasmInitialized) {
21711 throw new Error("initializeWasm() must be awaited first!");
21713 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_free(_res);
21714 // debug statements here
21716 // uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg);
21718 export function CResult_OnionMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21719 if(!isWasmInitialized) {
21720 throw new Error("initializeWasm() must be awaited first!");
21722 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(arg);
21723 return nativeResponseValue;
21725 // struct LDKCResult_OnionMessageDecodeErrorZ CResult_OnionMessageDecodeErrorZ_clone(const struct LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR orig);
21727 export function CResult_OnionMessageDecodeErrorZ_clone(orig: bigint): bigint {
21728 if(!isWasmInitialized) {
21729 throw new Error("initializeWasm() must be awaited first!");
21731 const nativeResponseValue = wasm.TS_CResult_OnionMessageDecodeErrorZ_clone(orig);
21732 return nativeResponseValue;
21734 // struct LDKCResult_FinalOnionHopDataDecodeErrorZ CResult_FinalOnionHopDataDecodeErrorZ_ok(struct LDKFinalOnionHopData o);
21736 export function CResult_FinalOnionHopDataDecodeErrorZ_ok(o: bigint): bigint {
21737 if(!isWasmInitialized) {
21738 throw new Error("initializeWasm() must be awaited first!");
21740 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_ok(o);
21741 return nativeResponseValue;
21743 // struct LDKCResult_FinalOnionHopDataDecodeErrorZ CResult_FinalOnionHopDataDecodeErrorZ_err(struct LDKDecodeError e);
21745 export function CResult_FinalOnionHopDataDecodeErrorZ_err(e: bigint): bigint {
21746 if(!isWasmInitialized) {
21747 throw new Error("initializeWasm() must be awaited first!");
21749 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_err(e);
21750 return nativeResponseValue;
21752 // bool CResult_FinalOnionHopDataDecodeErrorZ_is_ok(const struct LDKCResult_FinalOnionHopDataDecodeErrorZ *NONNULL_PTR o);
21754 export function CResult_FinalOnionHopDataDecodeErrorZ_is_ok(o: bigint): boolean {
21755 if(!isWasmInitialized) {
21756 throw new Error("initializeWasm() must be awaited first!");
21758 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_is_ok(o);
21759 return nativeResponseValue;
21761 // void CResult_FinalOnionHopDataDecodeErrorZ_free(struct LDKCResult_FinalOnionHopDataDecodeErrorZ _res);
21763 export function CResult_FinalOnionHopDataDecodeErrorZ_free(_res: bigint): void {
21764 if(!isWasmInitialized) {
21765 throw new Error("initializeWasm() must be awaited first!");
21767 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_free(_res);
21768 // debug statements here
21770 // uint64_t CResult_FinalOnionHopDataDecodeErrorZ_clone_ptr(LDKCResult_FinalOnionHopDataDecodeErrorZ *NONNULL_PTR arg);
21772 export function CResult_FinalOnionHopDataDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21773 if(!isWasmInitialized) {
21774 throw new Error("initializeWasm() must be awaited first!");
21776 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_clone_ptr(arg);
21777 return nativeResponseValue;
21779 // struct LDKCResult_FinalOnionHopDataDecodeErrorZ CResult_FinalOnionHopDataDecodeErrorZ_clone(const struct LDKCResult_FinalOnionHopDataDecodeErrorZ *NONNULL_PTR orig);
21781 export function CResult_FinalOnionHopDataDecodeErrorZ_clone(orig: bigint): bigint {
21782 if(!isWasmInitialized) {
21783 throw new Error("initializeWasm() must be awaited first!");
21785 const nativeResponseValue = wasm.TS_CResult_FinalOnionHopDataDecodeErrorZ_clone(orig);
21786 return nativeResponseValue;
21788 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
21790 export function CResult_PingDecodeErrorZ_ok(o: bigint): bigint {
21791 if(!isWasmInitialized) {
21792 throw new Error("initializeWasm() must be awaited first!");
21794 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
21795 return nativeResponseValue;
21797 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
21799 export function CResult_PingDecodeErrorZ_err(e: bigint): bigint {
21800 if(!isWasmInitialized) {
21801 throw new Error("initializeWasm() must be awaited first!");
21803 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
21804 return nativeResponseValue;
21806 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
21808 export function CResult_PingDecodeErrorZ_is_ok(o: bigint): boolean {
21809 if(!isWasmInitialized) {
21810 throw new Error("initializeWasm() must be awaited first!");
21812 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
21813 return nativeResponseValue;
21815 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
21817 export function CResult_PingDecodeErrorZ_free(_res: bigint): void {
21818 if(!isWasmInitialized) {
21819 throw new Error("initializeWasm() must be awaited first!");
21821 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
21822 // debug statements here
21824 // uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
21826 export function CResult_PingDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21827 if(!isWasmInitialized) {
21828 throw new Error("initializeWasm() must be awaited first!");
21830 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
21831 return nativeResponseValue;
21833 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
21835 export function CResult_PingDecodeErrorZ_clone(orig: bigint): bigint {
21836 if(!isWasmInitialized) {
21837 throw new Error("initializeWasm() must be awaited first!");
21839 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
21840 return nativeResponseValue;
21842 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
21844 export function CResult_PongDecodeErrorZ_ok(o: bigint): bigint {
21845 if(!isWasmInitialized) {
21846 throw new Error("initializeWasm() must be awaited first!");
21848 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
21849 return nativeResponseValue;
21851 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
21853 export function CResult_PongDecodeErrorZ_err(e: bigint): bigint {
21854 if(!isWasmInitialized) {
21855 throw new Error("initializeWasm() must be awaited first!");
21857 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
21858 return nativeResponseValue;
21860 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
21862 export function CResult_PongDecodeErrorZ_is_ok(o: bigint): boolean {
21863 if(!isWasmInitialized) {
21864 throw new Error("initializeWasm() must be awaited first!");
21866 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
21867 return nativeResponseValue;
21869 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
21871 export function CResult_PongDecodeErrorZ_free(_res: bigint): void {
21872 if(!isWasmInitialized) {
21873 throw new Error("initializeWasm() must be awaited first!");
21875 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
21876 // debug statements here
21878 // uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
21880 export function CResult_PongDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21881 if(!isWasmInitialized) {
21882 throw new Error("initializeWasm() must be awaited first!");
21884 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
21885 return nativeResponseValue;
21887 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
21889 export function CResult_PongDecodeErrorZ_clone(orig: bigint): bigint {
21890 if(!isWasmInitialized) {
21891 throw new Error("initializeWasm() must be awaited first!");
21893 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
21894 return nativeResponseValue;
21896 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
21898 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
21899 if(!isWasmInitialized) {
21900 throw new Error("initializeWasm() must be awaited first!");
21902 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
21903 return nativeResponseValue;
21905 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
21907 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
21908 if(!isWasmInitialized) {
21909 throw new Error("initializeWasm() must be awaited first!");
21911 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
21912 return nativeResponseValue;
21914 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
21916 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
21917 if(!isWasmInitialized) {
21918 throw new Error("initializeWasm() must be awaited first!");
21920 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
21921 return nativeResponseValue;
21923 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
21925 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
21926 if(!isWasmInitialized) {
21927 throw new Error("initializeWasm() must be awaited first!");
21929 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
21930 // debug statements here
21932 // uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
21934 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21935 if(!isWasmInitialized) {
21936 throw new Error("initializeWasm() must be awaited first!");
21938 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
21939 return nativeResponseValue;
21941 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
21943 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
21944 if(!isWasmInitialized) {
21945 throw new Error("initializeWasm() must be awaited first!");
21947 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
21948 return nativeResponseValue;
21950 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
21952 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
21953 if(!isWasmInitialized) {
21954 throw new Error("initializeWasm() must be awaited first!");
21956 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
21957 return nativeResponseValue;
21959 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
21961 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: bigint): bigint {
21962 if(!isWasmInitialized) {
21963 throw new Error("initializeWasm() must be awaited first!");
21965 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
21966 return nativeResponseValue;
21968 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
21970 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
21971 if(!isWasmInitialized) {
21972 throw new Error("initializeWasm() must be awaited first!");
21974 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
21975 return nativeResponseValue;
21977 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
21979 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: bigint): void {
21980 if(!isWasmInitialized) {
21981 throw new Error("initializeWasm() must be awaited first!");
21983 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
21984 // debug statements here
21986 // uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
21988 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
21989 if(!isWasmInitialized) {
21990 throw new Error("initializeWasm() must be awaited first!");
21992 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
21993 return nativeResponseValue;
21995 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
21997 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
21998 if(!isWasmInitialized) {
21999 throw new Error("initializeWasm() must be awaited first!");
22001 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
22002 return nativeResponseValue;
22004 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
22006 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
22007 if(!isWasmInitialized) {
22008 throw new Error("initializeWasm() must be awaited first!");
22010 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
22011 return nativeResponseValue;
22013 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
22015 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
22016 if(!isWasmInitialized) {
22017 throw new Error("initializeWasm() must be awaited first!");
22019 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
22020 return nativeResponseValue;
22022 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
22024 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
22025 if(!isWasmInitialized) {
22026 throw new Error("initializeWasm() must be awaited first!");
22028 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
22029 return nativeResponseValue;
22031 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
22033 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: bigint): void {
22034 if(!isWasmInitialized) {
22035 throw new Error("initializeWasm() must be awaited first!");
22037 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
22038 // debug statements here
22040 // uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
22042 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22043 if(!isWasmInitialized) {
22044 throw new Error("initializeWasm() must be awaited first!");
22046 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
22047 return nativeResponseValue;
22049 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
22051 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
22052 if(!isWasmInitialized) {
22053 throw new Error("initializeWasm() must be awaited first!");
22055 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
22056 return nativeResponseValue;
22058 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
22060 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: bigint): bigint {
22061 if(!isWasmInitialized) {
22062 throw new Error("initializeWasm() must be awaited first!");
22064 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
22065 return nativeResponseValue;
22067 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
22069 export function CResult_ChannelUpdateDecodeErrorZ_err(e: bigint): bigint {
22070 if(!isWasmInitialized) {
22071 throw new Error("initializeWasm() must be awaited first!");
22073 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
22074 return nativeResponseValue;
22076 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
22078 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: bigint): boolean {
22079 if(!isWasmInitialized) {
22080 throw new Error("initializeWasm() must be awaited first!");
22082 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
22083 return nativeResponseValue;
22085 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
22087 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: bigint): void {
22088 if(!isWasmInitialized) {
22089 throw new Error("initializeWasm() must be awaited first!");
22091 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
22092 // debug statements here
22094 // uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
22096 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22097 if(!isWasmInitialized) {
22098 throw new Error("initializeWasm() must be awaited first!");
22100 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
22101 return nativeResponseValue;
22103 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
22105 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: bigint): bigint {
22106 if(!isWasmInitialized) {
22107 throw new Error("initializeWasm() must be awaited first!");
22109 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
22110 return nativeResponseValue;
22112 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
22114 export function CResult_ErrorMessageDecodeErrorZ_ok(o: bigint): bigint {
22115 if(!isWasmInitialized) {
22116 throw new Error("initializeWasm() must be awaited first!");
22118 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
22119 return nativeResponseValue;
22121 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
22123 export function CResult_ErrorMessageDecodeErrorZ_err(e: bigint): bigint {
22124 if(!isWasmInitialized) {
22125 throw new Error("initializeWasm() must be awaited first!");
22127 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
22128 return nativeResponseValue;
22130 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
22132 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: bigint): boolean {
22133 if(!isWasmInitialized) {
22134 throw new Error("initializeWasm() must be awaited first!");
22136 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
22137 return nativeResponseValue;
22139 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
22141 export function CResult_ErrorMessageDecodeErrorZ_free(_res: bigint): void {
22142 if(!isWasmInitialized) {
22143 throw new Error("initializeWasm() must be awaited first!");
22145 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
22146 // debug statements here
22148 // uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
22150 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22151 if(!isWasmInitialized) {
22152 throw new Error("initializeWasm() must be awaited first!");
22154 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
22155 return nativeResponseValue;
22157 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
22159 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: bigint): bigint {
22160 if(!isWasmInitialized) {
22161 throw new Error("initializeWasm() must be awaited first!");
22163 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
22164 return nativeResponseValue;
22166 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
22168 export function CResult_WarningMessageDecodeErrorZ_ok(o: bigint): bigint {
22169 if(!isWasmInitialized) {
22170 throw new Error("initializeWasm() must be awaited first!");
22172 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
22173 return nativeResponseValue;
22175 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
22177 export function CResult_WarningMessageDecodeErrorZ_err(e: bigint): bigint {
22178 if(!isWasmInitialized) {
22179 throw new Error("initializeWasm() must be awaited first!");
22181 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
22182 return nativeResponseValue;
22184 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
22186 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: bigint): boolean {
22187 if(!isWasmInitialized) {
22188 throw new Error("initializeWasm() must be awaited first!");
22190 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
22191 return nativeResponseValue;
22193 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
22195 export function CResult_WarningMessageDecodeErrorZ_free(_res: bigint): void {
22196 if(!isWasmInitialized) {
22197 throw new Error("initializeWasm() must be awaited first!");
22199 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
22200 // debug statements here
22202 // uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
22204 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22205 if(!isWasmInitialized) {
22206 throw new Error("initializeWasm() must be awaited first!");
22208 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
22209 return nativeResponseValue;
22211 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
22213 export function CResult_WarningMessageDecodeErrorZ_clone(orig: bigint): bigint {
22214 if(!isWasmInitialized) {
22215 throw new Error("initializeWasm() must be awaited first!");
22217 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
22218 return nativeResponseValue;
22220 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
22222 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
22223 if(!isWasmInitialized) {
22224 throw new Error("initializeWasm() must be awaited first!");
22226 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
22227 return nativeResponseValue;
22229 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
22231 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
22232 if(!isWasmInitialized) {
22233 throw new Error("initializeWasm() must be awaited first!");
22235 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
22236 return nativeResponseValue;
22238 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
22240 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
22241 if(!isWasmInitialized) {
22242 throw new Error("initializeWasm() must be awaited first!");
22244 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
22245 return nativeResponseValue;
22247 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
22249 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
22250 if(!isWasmInitialized) {
22251 throw new Error("initializeWasm() must be awaited first!");
22253 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
22254 // debug statements here
22256 // uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
22258 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22259 if(!isWasmInitialized) {
22260 throw new Error("initializeWasm() must be awaited first!");
22262 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
22263 return nativeResponseValue;
22265 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
22267 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
22268 if(!isWasmInitialized) {
22269 throw new Error("initializeWasm() must be awaited first!");
22271 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
22272 return nativeResponseValue;
22274 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
22276 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: bigint): bigint {
22277 if(!isWasmInitialized) {
22278 throw new Error("initializeWasm() must be awaited first!");
22280 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
22281 return nativeResponseValue;
22283 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
22285 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: bigint): bigint {
22286 if(!isWasmInitialized) {
22287 throw new Error("initializeWasm() must be awaited first!");
22289 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
22290 return nativeResponseValue;
22292 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
22294 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: bigint): boolean {
22295 if(!isWasmInitialized) {
22296 throw new Error("initializeWasm() must be awaited first!");
22298 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
22299 return nativeResponseValue;
22301 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
22303 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: bigint): void {
22304 if(!isWasmInitialized) {
22305 throw new Error("initializeWasm() must be awaited first!");
22307 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
22308 // debug statements here
22310 // uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
22312 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22313 if(!isWasmInitialized) {
22314 throw new Error("initializeWasm() must be awaited first!");
22316 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
22317 return nativeResponseValue;
22319 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
22321 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: bigint): bigint {
22322 if(!isWasmInitialized) {
22323 throw new Error("initializeWasm() must be awaited first!");
22325 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
22326 return nativeResponseValue;
22328 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
22330 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: bigint): bigint {
22331 if(!isWasmInitialized) {
22332 throw new Error("initializeWasm() must be awaited first!");
22334 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
22335 return nativeResponseValue;
22337 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
22339 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: bigint): bigint {
22340 if(!isWasmInitialized) {
22341 throw new Error("initializeWasm() must be awaited first!");
22343 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
22344 return nativeResponseValue;
22346 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
22348 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: bigint): boolean {
22349 if(!isWasmInitialized) {
22350 throw new Error("initializeWasm() must be awaited first!");
22352 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
22353 return nativeResponseValue;
22355 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
22357 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: bigint): void {
22358 if(!isWasmInitialized) {
22359 throw new Error("initializeWasm() must be awaited first!");
22361 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
22362 // debug statements here
22364 // uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
22366 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22367 if(!isWasmInitialized) {
22368 throw new Error("initializeWasm() must be awaited first!");
22370 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
22371 return nativeResponseValue;
22373 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
22375 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: bigint): bigint {
22376 if(!isWasmInitialized) {
22377 throw new Error("initializeWasm() must be awaited first!");
22379 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
22380 return nativeResponseValue;
22382 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
22384 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: bigint): bigint {
22385 if(!isWasmInitialized) {
22386 throw new Error("initializeWasm() must be awaited first!");
22388 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
22389 return nativeResponseValue;
22391 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
22393 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: bigint): bigint {
22394 if(!isWasmInitialized) {
22395 throw new Error("initializeWasm() must be awaited first!");
22397 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
22398 return nativeResponseValue;
22400 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
22402 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: bigint): boolean {
22403 if(!isWasmInitialized) {
22404 throw new Error("initializeWasm() must be awaited first!");
22406 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
22407 return nativeResponseValue;
22409 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
22411 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: bigint): void {
22412 if(!isWasmInitialized) {
22413 throw new Error("initializeWasm() must be awaited first!");
22415 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
22416 // debug statements here
22418 // uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
22420 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22421 if(!isWasmInitialized) {
22422 throw new Error("initializeWasm() must be awaited first!");
22424 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
22425 return nativeResponseValue;
22427 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
22429 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: bigint): bigint {
22430 if(!isWasmInitialized) {
22431 throw new Error("initializeWasm() must be awaited first!");
22433 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
22434 return nativeResponseValue;
22436 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
22438 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
22439 if(!isWasmInitialized) {
22440 throw new Error("initializeWasm() must be awaited first!");
22442 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
22443 return nativeResponseValue;
22445 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
22447 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: bigint): bigint {
22448 if(!isWasmInitialized) {
22449 throw new Error("initializeWasm() must be awaited first!");
22451 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
22452 return nativeResponseValue;
22454 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
22456 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
22457 if(!isWasmInitialized) {
22458 throw new Error("initializeWasm() must be awaited first!");
22460 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
22461 return nativeResponseValue;
22463 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
22465 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: bigint): void {
22466 if(!isWasmInitialized) {
22467 throw new Error("initializeWasm() must be awaited first!");
22469 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
22470 // debug statements here
22472 // uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
22474 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22475 if(!isWasmInitialized) {
22476 throw new Error("initializeWasm() must be awaited first!");
22478 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
22479 return nativeResponseValue;
22481 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
22483 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
22484 if(!isWasmInitialized) {
22485 throw new Error("initializeWasm() must be awaited first!");
22487 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
22488 return nativeResponseValue;
22490 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
22492 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: bigint): bigint {
22493 if(!isWasmInitialized) {
22494 throw new Error("initializeWasm() must be awaited first!");
22496 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
22497 return nativeResponseValue;
22499 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
22501 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: bigint): bigint {
22502 if(!isWasmInitialized) {
22503 throw new Error("initializeWasm() must be awaited first!");
22505 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
22506 return nativeResponseValue;
22508 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
22510 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: bigint): boolean {
22511 if(!isWasmInitialized) {
22512 throw new Error("initializeWasm() must be awaited first!");
22514 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
22515 return nativeResponseValue;
22517 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
22519 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: bigint): void {
22520 if(!isWasmInitialized) {
22521 throw new Error("initializeWasm() must be awaited first!");
22523 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
22524 // debug statements here
22526 // uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
22528 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22529 if(!isWasmInitialized) {
22530 throw new Error("initializeWasm() must be awaited first!");
22532 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
22533 return nativeResponseValue;
22535 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
22537 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: bigint): bigint {
22538 if(!isWasmInitialized) {
22539 throw new Error("initializeWasm() must be awaited first!");
22541 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
22542 return nativeResponseValue;
22544 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
22546 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: bigint): bigint {
22547 if(!isWasmInitialized) {
22548 throw new Error("initializeWasm() must be awaited first!");
22550 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
22551 return nativeResponseValue;
22553 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
22555 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: bigint): bigint {
22556 if(!isWasmInitialized) {
22557 throw new Error("initializeWasm() must be awaited first!");
22559 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
22560 return nativeResponseValue;
22562 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
22564 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: bigint): boolean {
22565 if(!isWasmInitialized) {
22566 throw new Error("initializeWasm() must be awaited first!");
22568 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
22569 return nativeResponseValue;
22571 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
22573 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: bigint): void {
22574 if(!isWasmInitialized) {
22575 throw new Error("initializeWasm() must be awaited first!");
22577 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
22578 // debug statements here
22580 // uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
22582 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22583 if(!isWasmInitialized) {
22584 throw new Error("initializeWasm() must be awaited first!");
22586 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
22587 return nativeResponseValue;
22589 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
22591 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: bigint): bigint {
22592 if(!isWasmInitialized) {
22593 throw new Error("initializeWasm() must be awaited first!");
22595 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
22596 return nativeResponseValue;
22598 // void CVec_PhantomRouteHintsZ_free(struct LDKCVec_PhantomRouteHintsZ _res);
22600 export function CVec_PhantomRouteHintsZ_free(_res: number): void {
22601 if(!isWasmInitialized) {
22602 throw new Error("initializeWasm() must be awaited first!");
22604 const nativeResponseValue = wasm.TS_CVec_PhantomRouteHintsZ_free(_res);
22605 // debug statements here
22607 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(struct LDKBolt11Invoice o);
22609 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(o: bigint): bigint {
22610 if(!isWasmInitialized) {
22611 throw new Error("initializeWasm() must be awaited first!");
22613 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(o);
22614 return nativeResponseValue;
22616 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
22618 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_err(e: bigint): bigint {
22619 if(!isWasmInitialized) {
22620 throw new Error("initializeWasm() must be awaited first!");
22622 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_err(e);
22623 return nativeResponseValue;
22625 // bool CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
22627 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(o: bigint): boolean {
22628 if(!isWasmInitialized) {
22629 throw new Error("initializeWasm() must be awaited first!");
22631 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(o);
22632 return nativeResponseValue;
22634 // void CResult_Bolt11InvoiceSignOrCreationErrorZ_free(struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ _res);
22636 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_free(_res: bigint): void {
22637 if(!isWasmInitialized) {
22638 throw new Error("initializeWasm() must be awaited first!");
22640 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_free(_res);
22641 // debug statements here
22643 // uint64_t CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
22645 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(arg: bigint): bigint {
22646 if(!isWasmInitialized) {
22647 throw new Error("initializeWasm() must be awaited first!");
22649 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(arg);
22650 return nativeResponseValue;
22652 // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
22654 export function CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig: bigint): bigint {
22655 if(!isWasmInitialized) {
22656 throw new Error("initializeWasm() must be awaited first!");
22658 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig);
22659 return nativeResponseValue;
22661 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_ok(struct LDKOffersMessage o);
22663 export function CResult_OffersMessageDecodeErrorZ_ok(o: bigint): bigint {
22664 if(!isWasmInitialized) {
22665 throw new Error("initializeWasm() must be awaited first!");
22667 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_ok(o);
22668 return nativeResponseValue;
22670 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_err(struct LDKDecodeError e);
22672 export function CResult_OffersMessageDecodeErrorZ_err(e: bigint): bigint {
22673 if(!isWasmInitialized) {
22674 throw new Error("initializeWasm() must be awaited first!");
22676 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_err(e);
22677 return nativeResponseValue;
22679 // bool CResult_OffersMessageDecodeErrorZ_is_ok(const struct LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR o);
22681 export function CResult_OffersMessageDecodeErrorZ_is_ok(o: bigint): boolean {
22682 if(!isWasmInitialized) {
22683 throw new Error("initializeWasm() must be awaited first!");
22685 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_is_ok(o);
22686 return nativeResponseValue;
22688 // void CResult_OffersMessageDecodeErrorZ_free(struct LDKCResult_OffersMessageDecodeErrorZ _res);
22690 export function CResult_OffersMessageDecodeErrorZ_free(_res: bigint): void {
22691 if(!isWasmInitialized) {
22692 throw new Error("initializeWasm() must be awaited first!");
22694 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_free(_res);
22695 // debug statements here
22697 // uint64_t CResult_OffersMessageDecodeErrorZ_clone_ptr(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR arg);
22699 export function CResult_OffersMessageDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22700 if(!isWasmInitialized) {
22701 throw new Error("initializeWasm() must be awaited first!");
22703 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_clone_ptr(arg);
22704 return nativeResponseValue;
22706 // struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_clone(const struct LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR orig);
22708 export function CResult_OffersMessageDecodeErrorZ_clone(orig: bigint): bigint {
22709 if(!isWasmInitialized) {
22710 throw new Error("initializeWasm() must be awaited first!");
22712 const nativeResponseValue = wasm.TS_CResult_OffersMessageDecodeErrorZ_clone(orig);
22713 return nativeResponseValue;
22715 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_some(enum LDKHTLCClaim o);
22717 export function COption_HTLCClaimZ_some(o: HTLCClaim): bigint {
22718 if(!isWasmInitialized) {
22719 throw new Error("initializeWasm() must be awaited first!");
22721 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_some(o);
22722 return nativeResponseValue;
22724 // struct LDKCOption_HTLCClaimZ COption_HTLCClaimZ_none(void);
22726 export function COption_HTLCClaimZ_none(): bigint {
22727 if(!isWasmInitialized) {
22728 throw new Error("initializeWasm() must be awaited first!");
22730 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_none();
22731 return nativeResponseValue;
22733 // void COption_HTLCClaimZ_free(struct LDKCOption_HTLCClaimZ _res);
22735 export function COption_HTLCClaimZ_free(_res: bigint): void {
22736 if(!isWasmInitialized) {
22737 throw new Error("initializeWasm() must be awaited first!");
22739 const nativeResponseValue = wasm.TS_COption_HTLCClaimZ_free(_res);
22740 // debug statements here
22742 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
22744 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: bigint): bigint {
22745 if(!isWasmInitialized) {
22746 throw new Error("initializeWasm() must be awaited first!");
22748 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
22749 return nativeResponseValue;
22751 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
22753 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: bigint): bigint {
22754 if(!isWasmInitialized) {
22755 throw new Error("initializeWasm() must be awaited first!");
22757 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
22758 return nativeResponseValue;
22760 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
22762 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: bigint): boolean {
22763 if(!isWasmInitialized) {
22764 throw new Error("initializeWasm() must be awaited first!");
22766 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
22767 return nativeResponseValue;
22769 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
22771 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: bigint): void {
22772 if(!isWasmInitialized) {
22773 throw new Error("initializeWasm() must be awaited first!");
22775 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
22776 // debug statements here
22778 // uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
22780 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22781 if(!isWasmInitialized) {
22782 throw new Error("initializeWasm() must be awaited first!");
22784 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
22785 return nativeResponseValue;
22787 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
22789 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: bigint): bigint {
22790 if(!isWasmInitialized) {
22791 throw new Error("initializeWasm() must be awaited first!");
22793 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
22794 return nativeResponseValue;
22796 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
22798 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: bigint): bigint {
22799 if(!isWasmInitialized) {
22800 throw new Error("initializeWasm() must be awaited first!");
22802 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
22803 return nativeResponseValue;
22805 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
22807 export function CResult_TxCreationKeysDecodeErrorZ_err(e: bigint): bigint {
22808 if(!isWasmInitialized) {
22809 throw new Error("initializeWasm() must be awaited first!");
22811 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
22812 return nativeResponseValue;
22814 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
22816 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: bigint): boolean {
22817 if(!isWasmInitialized) {
22818 throw new Error("initializeWasm() must be awaited first!");
22820 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
22821 return nativeResponseValue;
22823 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
22825 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: bigint): void {
22826 if(!isWasmInitialized) {
22827 throw new Error("initializeWasm() must be awaited first!");
22829 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
22830 // debug statements here
22832 // uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
22834 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22835 if(!isWasmInitialized) {
22836 throw new Error("initializeWasm() must be awaited first!");
22838 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
22839 return nativeResponseValue;
22841 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
22843 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: bigint): bigint {
22844 if(!isWasmInitialized) {
22845 throw new Error("initializeWasm() must be awaited first!");
22847 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
22848 return nativeResponseValue;
22850 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
22852 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: bigint): bigint {
22853 if(!isWasmInitialized) {
22854 throw new Error("initializeWasm() must be awaited first!");
22856 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
22857 return nativeResponseValue;
22859 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
22861 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: bigint): bigint {
22862 if(!isWasmInitialized) {
22863 throw new Error("initializeWasm() must be awaited first!");
22865 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
22866 return nativeResponseValue;
22868 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
22870 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: bigint): boolean {
22871 if(!isWasmInitialized) {
22872 throw new Error("initializeWasm() must be awaited first!");
22874 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
22875 return nativeResponseValue;
22877 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
22879 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: bigint): void {
22880 if(!isWasmInitialized) {
22881 throw new Error("initializeWasm() must be awaited first!");
22883 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
22884 // debug statements here
22886 // uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
22888 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22889 if(!isWasmInitialized) {
22890 throw new Error("initializeWasm() must be awaited first!");
22892 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
22893 return nativeResponseValue;
22895 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
22897 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: bigint): bigint {
22898 if(!isWasmInitialized) {
22899 throw new Error("initializeWasm() must be awaited first!");
22901 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
22902 return nativeResponseValue;
22904 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
22906 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: bigint): bigint {
22907 if(!isWasmInitialized) {
22908 throw new Error("initializeWasm() must be awaited first!");
22910 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
22911 return nativeResponseValue;
22913 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
22915 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: bigint): bigint {
22916 if(!isWasmInitialized) {
22917 throw new Error("initializeWasm() must be awaited first!");
22919 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
22920 return nativeResponseValue;
22922 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
22924 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: bigint): boolean {
22925 if(!isWasmInitialized) {
22926 throw new Error("initializeWasm() must be awaited first!");
22928 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
22929 return nativeResponseValue;
22931 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
22933 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: bigint): void {
22934 if(!isWasmInitialized) {
22935 throw new Error("initializeWasm() must be awaited first!");
22937 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
22938 // debug statements here
22940 // uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
22942 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22943 if(!isWasmInitialized) {
22944 throw new Error("initializeWasm() must be awaited first!");
22946 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
22947 return nativeResponseValue;
22949 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
22951 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: bigint): bigint {
22952 if(!isWasmInitialized) {
22953 throw new Error("initializeWasm() must be awaited first!");
22955 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
22956 return nativeResponseValue;
22958 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
22960 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
22961 if(!isWasmInitialized) {
22962 throw new Error("initializeWasm() must be awaited first!");
22964 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
22965 return nativeResponseValue;
22967 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
22969 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
22970 if(!isWasmInitialized) {
22971 throw new Error("initializeWasm() must be awaited first!");
22973 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
22974 return nativeResponseValue;
22976 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
22978 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
22979 if(!isWasmInitialized) {
22980 throw new Error("initializeWasm() must be awaited first!");
22982 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
22983 return nativeResponseValue;
22985 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
22987 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
22988 if(!isWasmInitialized) {
22989 throw new Error("initializeWasm() must be awaited first!");
22991 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
22992 // debug statements here
22994 // uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
22996 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
22997 if(!isWasmInitialized) {
22998 throw new Error("initializeWasm() must be awaited first!");
23000 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
23001 return nativeResponseValue;
23003 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
23005 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
23006 if(!isWasmInitialized) {
23007 throw new Error("initializeWasm() must be awaited first!");
23009 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
23010 return nativeResponseValue;
23012 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
23014 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: bigint): bigint {
23015 if(!isWasmInitialized) {
23016 throw new Error("initializeWasm() must be awaited first!");
23018 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
23019 return nativeResponseValue;
23021 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
23023 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: bigint): bigint {
23024 if(!isWasmInitialized) {
23025 throw new Error("initializeWasm() must be awaited first!");
23027 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
23028 return nativeResponseValue;
23030 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
23032 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: bigint): boolean {
23033 if(!isWasmInitialized) {
23034 throw new Error("initializeWasm() must be awaited first!");
23036 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
23037 return nativeResponseValue;
23039 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
23041 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: bigint): void {
23042 if(!isWasmInitialized) {
23043 throw new Error("initializeWasm() must be awaited first!");
23045 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
23046 // debug statements here
23048 // uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
23050 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23051 if(!isWasmInitialized) {
23052 throw new Error("initializeWasm() must be awaited first!");
23054 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
23055 return nativeResponseValue;
23057 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
23059 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: bigint): bigint {
23060 if(!isWasmInitialized) {
23061 throw new Error("initializeWasm() must be awaited first!");
23063 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
23064 return nativeResponseValue;
23066 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
23068 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
23069 if(!isWasmInitialized) {
23070 throw new Error("initializeWasm() must be awaited first!");
23072 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
23073 return nativeResponseValue;
23075 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
23077 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
23078 if(!isWasmInitialized) {
23079 throw new Error("initializeWasm() must be awaited first!");
23081 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
23082 return nativeResponseValue;
23084 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
23086 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
23087 if(!isWasmInitialized) {
23088 throw new Error("initializeWasm() must be awaited first!");
23090 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
23091 return nativeResponseValue;
23093 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
23095 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
23096 if(!isWasmInitialized) {
23097 throw new Error("initializeWasm() must be awaited first!");
23099 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
23100 // debug statements here
23102 // uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
23104 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23105 if(!isWasmInitialized) {
23106 throw new Error("initializeWasm() must be awaited first!");
23108 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
23109 return nativeResponseValue;
23111 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
23113 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
23114 if(!isWasmInitialized) {
23115 throw new Error("initializeWasm() must be awaited first!");
23117 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
23118 return nativeResponseValue;
23120 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
23122 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
23123 if(!isWasmInitialized) {
23124 throw new Error("initializeWasm() must be awaited first!");
23126 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
23127 return nativeResponseValue;
23129 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
23131 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
23132 if(!isWasmInitialized) {
23133 throw new Error("initializeWasm() must be awaited first!");
23135 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
23136 return nativeResponseValue;
23138 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
23140 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
23141 if(!isWasmInitialized) {
23142 throw new Error("initializeWasm() must be awaited first!");
23144 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
23145 return nativeResponseValue;
23147 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
23149 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
23150 if(!isWasmInitialized) {
23151 throw new Error("initializeWasm() must be awaited first!");
23153 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
23154 // debug statements here
23156 // uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
23158 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23159 if(!isWasmInitialized) {
23160 throw new Error("initializeWasm() must be awaited first!");
23162 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
23163 return nativeResponseValue;
23165 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
23167 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
23168 if(!isWasmInitialized) {
23169 throw new Error("initializeWasm() must be awaited first!");
23171 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
23172 return nativeResponseValue;
23174 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
23176 export function CResult_TrustedClosingTransactionNoneZ_ok(o: bigint): bigint {
23177 if(!isWasmInitialized) {
23178 throw new Error("initializeWasm() must be awaited first!");
23180 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
23181 return nativeResponseValue;
23183 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
23185 export function CResult_TrustedClosingTransactionNoneZ_err(): bigint {
23186 if(!isWasmInitialized) {
23187 throw new Error("initializeWasm() must be awaited first!");
23189 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
23190 return nativeResponseValue;
23192 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
23194 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: bigint): boolean {
23195 if(!isWasmInitialized) {
23196 throw new Error("initializeWasm() must be awaited first!");
23198 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
23199 return nativeResponseValue;
23201 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
23203 export function CResult_TrustedClosingTransactionNoneZ_free(_res: bigint): void {
23204 if(!isWasmInitialized) {
23205 throw new Error("initializeWasm() must be awaited first!");
23207 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
23208 // debug statements here
23210 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
23212 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: bigint): bigint {
23213 if(!isWasmInitialized) {
23214 throw new Error("initializeWasm() must be awaited first!");
23216 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
23217 return nativeResponseValue;
23219 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
23221 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: bigint): bigint {
23222 if(!isWasmInitialized) {
23223 throw new Error("initializeWasm() must be awaited first!");
23225 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
23226 return nativeResponseValue;
23228 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
23230 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: bigint): boolean {
23231 if(!isWasmInitialized) {
23232 throw new Error("initializeWasm() must be awaited first!");
23234 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
23235 return nativeResponseValue;
23237 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
23239 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: bigint): void {
23240 if(!isWasmInitialized) {
23241 throw new Error("initializeWasm() must be awaited first!");
23243 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
23244 // debug statements here
23246 // uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
23248 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23249 if(!isWasmInitialized) {
23250 throw new Error("initializeWasm() must be awaited first!");
23252 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
23253 return nativeResponseValue;
23255 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
23257 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: bigint): bigint {
23258 if(!isWasmInitialized) {
23259 throw new Error("initializeWasm() must be awaited first!");
23261 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
23262 return nativeResponseValue;
23264 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
23266 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: bigint): bigint {
23267 if(!isWasmInitialized) {
23268 throw new Error("initializeWasm() must be awaited first!");
23270 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
23271 return nativeResponseValue;
23273 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
23275 export function CResult_TrustedCommitmentTransactionNoneZ_err(): bigint {
23276 if(!isWasmInitialized) {
23277 throw new Error("initializeWasm() must be awaited first!");
23279 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
23280 return nativeResponseValue;
23282 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
23284 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: bigint): boolean {
23285 if(!isWasmInitialized) {
23286 throw new Error("initializeWasm() must be awaited first!");
23288 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
23289 return nativeResponseValue;
23291 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
23293 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: bigint): void {
23294 if(!isWasmInitialized) {
23295 throw new Error("initializeWasm() must be awaited first!");
23297 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
23298 // debug statements here
23300 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_ok(struct LDKCVec_ECDSASignatureZ o);
23302 export function CResult_CVec_ECDSASignatureZNoneZ_ok(o: number): bigint {
23303 if(!isWasmInitialized) {
23304 throw new Error("initializeWasm() must be awaited first!");
23306 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_ok(o);
23307 return nativeResponseValue;
23309 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_err(void);
23311 export function CResult_CVec_ECDSASignatureZNoneZ_err(): bigint {
23312 if(!isWasmInitialized) {
23313 throw new Error("initializeWasm() must be awaited first!");
23315 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_err();
23316 return nativeResponseValue;
23318 // bool CResult_CVec_ECDSASignatureZNoneZ_is_ok(const struct LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR o);
23320 export function CResult_CVec_ECDSASignatureZNoneZ_is_ok(o: bigint): boolean {
23321 if(!isWasmInitialized) {
23322 throw new Error("initializeWasm() must be awaited first!");
23324 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_is_ok(o);
23325 return nativeResponseValue;
23327 // void CResult_CVec_ECDSASignatureZNoneZ_free(struct LDKCResult_CVec_ECDSASignatureZNoneZ _res);
23329 export function CResult_CVec_ECDSASignatureZNoneZ_free(_res: bigint): void {
23330 if(!isWasmInitialized) {
23331 throw new Error("initializeWasm() must be awaited first!");
23333 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_free(_res);
23334 // debug statements here
23336 // uint64_t CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR arg);
23338 export function CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(arg: bigint): bigint {
23339 if(!isWasmInitialized) {
23340 throw new Error("initializeWasm() must be awaited first!");
23342 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(arg);
23343 return nativeResponseValue;
23345 // struct LDKCResult_CVec_ECDSASignatureZNoneZ CResult_CVec_ECDSASignatureZNoneZ_clone(const struct LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR orig);
23347 export function CResult_CVec_ECDSASignatureZNoneZ_clone(orig: bigint): bigint {
23348 if(!isWasmInitialized) {
23349 throw new Error("initializeWasm() must be awaited first!");
23351 const nativeResponseValue = wasm.TS_CResult_CVec_ECDSASignatureZNoneZ_clone(orig);
23352 return nativeResponseValue;
23354 // struct LDKCOption_usizeZ COption_usizeZ_some(uintptr_t o);
23356 export function COption_usizeZ_some(o: number): bigint {
23357 if(!isWasmInitialized) {
23358 throw new Error("initializeWasm() must be awaited first!");
23360 const nativeResponseValue = wasm.TS_COption_usizeZ_some(o);
23361 return nativeResponseValue;
23363 // struct LDKCOption_usizeZ COption_usizeZ_none(void);
23365 export function COption_usizeZ_none(): bigint {
23366 if(!isWasmInitialized) {
23367 throw new Error("initializeWasm() must be awaited first!");
23369 const nativeResponseValue = wasm.TS_COption_usizeZ_none();
23370 return nativeResponseValue;
23372 // void COption_usizeZ_free(struct LDKCOption_usizeZ _res);
23374 export function COption_usizeZ_free(_res: bigint): void {
23375 if(!isWasmInitialized) {
23376 throw new Error("initializeWasm() must be awaited first!");
23378 const nativeResponseValue = wasm.TS_COption_usizeZ_free(_res);
23379 // debug statements here
23381 // uint64_t COption_usizeZ_clone_ptr(LDKCOption_usizeZ *NONNULL_PTR arg);
23383 export function COption_usizeZ_clone_ptr(arg: bigint): bigint {
23384 if(!isWasmInitialized) {
23385 throw new Error("initializeWasm() must be awaited first!");
23387 const nativeResponseValue = wasm.TS_COption_usizeZ_clone_ptr(arg);
23388 return nativeResponseValue;
23390 // struct LDKCOption_usizeZ COption_usizeZ_clone(const struct LDKCOption_usizeZ *NONNULL_PTR orig);
23392 export function COption_usizeZ_clone(orig: bigint): bigint {
23393 if(!isWasmInitialized) {
23394 throw new Error("initializeWasm() must be awaited first!");
23396 const nativeResponseValue = wasm.TS_COption_usizeZ_clone(orig);
23397 return nativeResponseValue;
23399 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
23401 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: bigint): bigint {
23402 if(!isWasmInitialized) {
23403 throw new Error("initializeWasm() must be awaited first!");
23405 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
23406 return nativeResponseValue;
23408 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
23410 export function CResult_ShutdownScriptDecodeErrorZ_err(e: bigint): bigint {
23411 if(!isWasmInitialized) {
23412 throw new Error("initializeWasm() must be awaited first!");
23414 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
23415 return nativeResponseValue;
23417 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
23419 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: bigint): boolean {
23420 if(!isWasmInitialized) {
23421 throw new Error("initializeWasm() must be awaited first!");
23423 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
23424 return nativeResponseValue;
23426 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
23428 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: bigint): void {
23429 if(!isWasmInitialized) {
23430 throw new Error("initializeWasm() must be awaited first!");
23432 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
23433 // debug statements here
23435 // uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
23437 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23438 if(!isWasmInitialized) {
23439 throw new Error("initializeWasm() must be awaited first!");
23441 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
23442 return nativeResponseValue;
23444 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
23446 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: bigint): bigint {
23447 if(!isWasmInitialized) {
23448 throw new Error("initializeWasm() must be awaited first!");
23450 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
23451 return nativeResponseValue;
23453 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
23455 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: bigint): bigint {
23456 if(!isWasmInitialized) {
23457 throw new Error("initializeWasm() must be awaited first!");
23459 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
23460 return nativeResponseValue;
23462 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
23464 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: bigint): bigint {
23465 if(!isWasmInitialized) {
23466 throw new Error("initializeWasm() must be awaited first!");
23468 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
23469 return nativeResponseValue;
23471 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
23473 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: bigint): boolean {
23474 if(!isWasmInitialized) {
23475 throw new Error("initializeWasm() must be awaited first!");
23477 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
23478 return nativeResponseValue;
23480 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
23482 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: bigint): void {
23483 if(!isWasmInitialized) {
23484 throw new Error("initializeWasm() must be awaited first!");
23486 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
23487 // debug statements here
23489 // uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
23491 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: bigint): bigint {
23492 if(!isWasmInitialized) {
23493 throw new Error("initializeWasm() must be awaited first!");
23495 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
23496 return nativeResponseValue;
23498 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
23500 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: bigint): bigint {
23501 if(!isWasmInitialized) {
23502 throw new Error("initializeWasm() must be awaited first!");
23504 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
23505 return nativeResponseValue;
23507 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
23509 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: bigint): bigint {
23510 if(!isWasmInitialized) {
23511 throw new Error("initializeWasm() must be awaited first!");
23513 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
23514 return nativeResponseValue;
23516 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
23518 export function CResult_PaymentPurposeDecodeErrorZ_err(e: bigint): bigint {
23519 if(!isWasmInitialized) {
23520 throw new Error("initializeWasm() must be awaited first!");
23522 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
23523 return nativeResponseValue;
23525 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
23527 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: bigint): boolean {
23528 if(!isWasmInitialized) {
23529 throw new Error("initializeWasm() must be awaited first!");
23531 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
23532 return nativeResponseValue;
23534 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
23536 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: bigint): void {
23537 if(!isWasmInitialized) {
23538 throw new Error("initializeWasm() must be awaited first!");
23540 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
23541 // debug statements here
23543 // uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
23545 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23546 if(!isWasmInitialized) {
23547 throw new Error("initializeWasm() must be awaited first!");
23549 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
23550 return nativeResponseValue;
23552 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
23554 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: bigint): bigint {
23555 if(!isWasmInitialized) {
23556 throw new Error("initializeWasm() must be awaited first!");
23558 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
23559 return nativeResponseValue;
23561 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_ok(struct LDKClaimedHTLC o);
23563 export function CResult_ClaimedHTLCDecodeErrorZ_ok(o: bigint): bigint {
23564 if(!isWasmInitialized) {
23565 throw new Error("initializeWasm() must be awaited first!");
23567 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_ok(o);
23568 return nativeResponseValue;
23570 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
23572 export function CResult_ClaimedHTLCDecodeErrorZ_err(e: bigint): bigint {
23573 if(!isWasmInitialized) {
23574 throw new Error("initializeWasm() must be awaited first!");
23576 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_err(e);
23577 return nativeResponseValue;
23579 // bool CResult_ClaimedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR o);
23581 export function CResult_ClaimedHTLCDecodeErrorZ_is_ok(o: bigint): boolean {
23582 if(!isWasmInitialized) {
23583 throw new Error("initializeWasm() must be awaited first!");
23585 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_is_ok(o);
23586 return nativeResponseValue;
23588 // void CResult_ClaimedHTLCDecodeErrorZ_free(struct LDKCResult_ClaimedHTLCDecodeErrorZ _res);
23590 export function CResult_ClaimedHTLCDecodeErrorZ_free(_res: bigint): void {
23591 if(!isWasmInitialized) {
23592 throw new Error("initializeWasm() must be awaited first!");
23594 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_free(_res);
23595 // debug statements here
23597 // uint64_t CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR arg);
23599 export function CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23600 if(!isWasmInitialized) {
23601 throw new Error("initializeWasm() must be awaited first!");
23603 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(arg);
23604 return nativeResponseValue;
23606 // struct LDKCResult_ClaimedHTLCDecodeErrorZ CResult_ClaimedHTLCDecodeErrorZ_clone(const struct LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR orig);
23608 export function CResult_ClaimedHTLCDecodeErrorZ_clone(orig: bigint): bigint {
23609 if(!isWasmInitialized) {
23610 throw new Error("initializeWasm() must be awaited first!");
23612 const nativeResponseValue = wasm.TS_CResult_ClaimedHTLCDecodeErrorZ_clone(orig);
23613 return nativeResponseValue;
23615 // struct LDKCOption_PathFailureZ COption_PathFailureZ_some(struct LDKPathFailure o);
23617 export function COption_PathFailureZ_some(o: bigint): bigint {
23618 if(!isWasmInitialized) {
23619 throw new Error("initializeWasm() must be awaited first!");
23621 const nativeResponseValue = wasm.TS_COption_PathFailureZ_some(o);
23622 return nativeResponseValue;
23624 // struct LDKCOption_PathFailureZ COption_PathFailureZ_none(void);
23626 export function COption_PathFailureZ_none(): bigint {
23627 if(!isWasmInitialized) {
23628 throw new Error("initializeWasm() must be awaited first!");
23630 const nativeResponseValue = wasm.TS_COption_PathFailureZ_none();
23631 return nativeResponseValue;
23633 // void COption_PathFailureZ_free(struct LDKCOption_PathFailureZ _res);
23635 export function COption_PathFailureZ_free(_res: bigint): void {
23636 if(!isWasmInitialized) {
23637 throw new Error("initializeWasm() must be awaited first!");
23639 const nativeResponseValue = wasm.TS_COption_PathFailureZ_free(_res);
23640 // debug statements here
23642 // uint64_t COption_PathFailureZ_clone_ptr(LDKCOption_PathFailureZ *NONNULL_PTR arg);
23644 export function COption_PathFailureZ_clone_ptr(arg: bigint): bigint {
23645 if(!isWasmInitialized) {
23646 throw new Error("initializeWasm() must be awaited first!");
23648 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone_ptr(arg);
23649 return nativeResponseValue;
23651 // struct LDKCOption_PathFailureZ COption_PathFailureZ_clone(const struct LDKCOption_PathFailureZ *NONNULL_PTR orig);
23653 export function COption_PathFailureZ_clone(orig: bigint): bigint {
23654 if(!isWasmInitialized) {
23655 throw new Error("initializeWasm() must be awaited first!");
23657 const nativeResponseValue = wasm.TS_COption_PathFailureZ_clone(orig);
23658 return nativeResponseValue;
23660 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_ok(struct LDKCOption_PathFailureZ o);
23662 export function CResult_COption_PathFailureZDecodeErrorZ_ok(o: bigint): bigint {
23663 if(!isWasmInitialized) {
23664 throw new Error("initializeWasm() must be awaited first!");
23666 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_ok(o);
23667 return nativeResponseValue;
23669 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_err(struct LDKDecodeError e);
23671 export function CResult_COption_PathFailureZDecodeErrorZ_err(e: bigint): bigint {
23672 if(!isWasmInitialized) {
23673 throw new Error("initializeWasm() must be awaited first!");
23675 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_err(e);
23676 return nativeResponseValue;
23678 // bool CResult_COption_PathFailureZDecodeErrorZ_is_ok(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR o);
23680 export function CResult_COption_PathFailureZDecodeErrorZ_is_ok(o: bigint): boolean {
23681 if(!isWasmInitialized) {
23682 throw new Error("initializeWasm() must be awaited first!");
23684 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok(o);
23685 return nativeResponseValue;
23687 // void CResult_COption_PathFailureZDecodeErrorZ_free(struct LDKCResult_COption_PathFailureZDecodeErrorZ _res);
23689 export function CResult_COption_PathFailureZDecodeErrorZ_free(_res: bigint): void {
23690 if(!isWasmInitialized) {
23691 throw new Error("initializeWasm() must be awaited first!");
23693 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_free(_res);
23694 // debug statements here
23696 // uint64_t CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR arg);
23698 export function CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23699 if(!isWasmInitialized) {
23700 throw new Error("initializeWasm() must be awaited first!");
23702 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg);
23703 return nativeResponseValue;
23705 // struct LDKCResult_COption_PathFailureZDecodeErrorZ CResult_COption_PathFailureZDecodeErrorZ_clone(const struct LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR orig);
23707 export function CResult_COption_PathFailureZDecodeErrorZ_clone(orig: bigint): bigint {
23708 if(!isWasmInitialized) {
23709 throw new Error("initializeWasm() must be awaited first!");
23711 const nativeResponseValue = wasm.TS_CResult_COption_PathFailureZDecodeErrorZ_clone(orig);
23712 return nativeResponseValue;
23714 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
23716 export function COption_ClosureReasonZ_some(o: bigint): bigint {
23717 if(!isWasmInitialized) {
23718 throw new Error("initializeWasm() must be awaited first!");
23720 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
23721 return nativeResponseValue;
23723 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
23725 export function COption_ClosureReasonZ_none(): bigint {
23726 if(!isWasmInitialized) {
23727 throw new Error("initializeWasm() must be awaited first!");
23729 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
23730 return nativeResponseValue;
23732 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
23734 export function COption_ClosureReasonZ_free(_res: bigint): void {
23735 if(!isWasmInitialized) {
23736 throw new Error("initializeWasm() must be awaited first!");
23738 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
23739 // debug statements here
23741 // uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
23743 export function COption_ClosureReasonZ_clone_ptr(arg: bigint): bigint {
23744 if(!isWasmInitialized) {
23745 throw new Error("initializeWasm() must be awaited first!");
23747 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
23748 return nativeResponseValue;
23750 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
23752 export function COption_ClosureReasonZ_clone(orig: bigint): bigint {
23753 if(!isWasmInitialized) {
23754 throw new Error("initializeWasm() must be awaited first!");
23756 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
23757 return nativeResponseValue;
23759 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
23761 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: bigint): bigint {
23762 if(!isWasmInitialized) {
23763 throw new Error("initializeWasm() must be awaited first!");
23765 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
23766 return nativeResponseValue;
23768 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
23770 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: bigint): bigint {
23771 if(!isWasmInitialized) {
23772 throw new Error("initializeWasm() must be awaited first!");
23774 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
23775 return nativeResponseValue;
23777 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
23779 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: bigint): boolean {
23780 if(!isWasmInitialized) {
23781 throw new Error("initializeWasm() must be awaited first!");
23783 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
23784 return nativeResponseValue;
23786 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
23788 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: bigint): void {
23789 if(!isWasmInitialized) {
23790 throw new Error("initializeWasm() must be awaited first!");
23792 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
23793 // debug statements here
23795 // uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
23797 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23798 if(!isWasmInitialized) {
23799 throw new Error("initializeWasm() must be awaited first!");
23801 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
23802 return nativeResponseValue;
23804 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
23806 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: bigint): bigint {
23807 if(!isWasmInitialized) {
23808 throw new Error("initializeWasm() must be awaited first!");
23810 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
23811 return nativeResponseValue;
23813 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
23815 export function COption_HTLCDestinationZ_some(o: bigint): bigint {
23816 if(!isWasmInitialized) {
23817 throw new Error("initializeWasm() must be awaited first!");
23819 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
23820 return nativeResponseValue;
23822 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
23824 export function COption_HTLCDestinationZ_none(): bigint {
23825 if(!isWasmInitialized) {
23826 throw new Error("initializeWasm() must be awaited first!");
23828 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
23829 return nativeResponseValue;
23831 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
23833 export function COption_HTLCDestinationZ_free(_res: bigint): void {
23834 if(!isWasmInitialized) {
23835 throw new Error("initializeWasm() must be awaited first!");
23837 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
23838 // debug statements here
23840 // uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
23842 export function COption_HTLCDestinationZ_clone_ptr(arg: bigint): bigint {
23843 if(!isWasmInitialized) {
23844 throw new Error("initializeWasm() must be awaited first!");
23846 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
23847 return nativeResponseValue;
23849 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
23851 export function COption_HTLCDestinationZ_clone(orig: bigint): bigint {
23852 if(!isWasmInitialized) {
23853 throw new Error("initializeWasm() must be awaited first!");
23855 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
23856 return nativeResponseValue;
23858 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
23860 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: bigint): bigint {
23861 if(!isWasmInitialized) {
23862 throw new Error("initializeWasm() must be awaited first!");
23864 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
23865 return nativeResponseValue;
23867 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
23869 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: bigint): bigint {
23870 if(!isWasmInitialized) {
23871 throw new Error("initializeWasm() must be awaited first!");
23873 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
23874 return nativeResponseValue;
23876 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
23878 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: bigint): boolean {
23879 if(!isWasmInitialized) {
23880 throw new Error("initializeWasm() must be awaited first!");
23882 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
23883 return nativeResponseValue;
23885 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
23887 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: bigint): void {
23888 if(!isWasmInitialized) {
23889 throw new Error("initializeWasm() must be awaited first!");
23891 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
23892 // debug statements here
23894 // uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
23896 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23897 if(!isWasmInitialized) {
23898 throw new Error("initializeWasm() must be awaited first!");
23900 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
23901 return nativeResponseValue;
23903 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
23905 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: bigint): bigint {
23906 if(!isWasmInitialized) {
23907 throw new Error("initializeWasm() must be awaited first!");
23909 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
23910 return nativeResponseValue;
23912 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_ok(enum LDKPaymentFailureReason o);
23914 export function CResult_PaymentFailureReasonDecodeErrorZ_ok(o: PaymentFailureReason): bigint {
23915 if(!isWasmInitialized) {
23916 throw new Error("initializeWasm() must be awaited first!");
23918 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_ok(o);
23919 return nativeResponseValue;
23921 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_err(struct LDKDecodeError e);
23923 export function CResult_PaymentFailureReasonDecodeErrorZ_err(e: bigint): bigint {
23924 if(!isWasmInitialized) {
23925 throw new Error("initializeWasm() must be awaited first!");
23927 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_err(e);
23928 return nativeResponseValue;
23930 // bool CResult_PaymentFailureReasonDecodeErrorZ_is_ok(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR o);
23932 export function CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o: bigint): boolean {
23933 if(!isWasmInitialized) {
23934 throw new Error("initializeWasm() must be awaited first!");
23936 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o);
23937 return nativeResponseValue;
23939 // void CResult_PaymentFailureReasonDecodeErrorZ_free(struct LDKCResult_PaymentFailureReasonDecodeErrorZ _res);
23941 export function CResult_PaymentFailureReasonDecodeErrorZ_free(_res: bigint): void {
23942 if(!isWasmInitialized) {
23943 throw new Error("initializeWasm() must be awaited first!");
23945 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_free(_res);
23946 // debug statements here
23948 // uint64_t CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR arg);
23950 export function CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg: bigint): bigint {
23951 if(!isWasmInitialized) {
23952 throw new Error("initializeWasm() must be awaited first!");
23954 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg);
23955 return nativeResponseValue;
23957 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ CResult_PaymentFailureReasonDecodeErrorZ_clone(const struct LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR orig);
23959 export function CResult_PaymentFailureReasonDecodeErrorZ_clone(orig: bigint): bigint {
23960 if(!isWasmInitialized) {
23961 throw new Error("initializeWasm() must be awaited first!");
23963 const nativeResponseValue = wasm.TS_CResult_PaymentFailureReasonDecodeErrorZ_clone(orig);
23964 return nativeResponseValue;
23966 // struct LDKCOption_U128Z COption_U128Z_some(struct LDKU128 o);
23968 export function COption_U128Z_some(o: number): bigint {
23969 if(!isWasmInitialized) {
23970 throw new Error("initializeWasm() must be awaited first!");
23972 const nativeResponseValue = wasm.TS_COption_U128Z_some(o);
23973 return nativeResponseValue;
23975 // struct LDKCOption_U128Z COption_U128Z_none(void);
23977 export function COption_U128Z_none(): bigint {
23978 if(!isWasmInitialized) {
23979 throw new Error("initializeWasm() must be awaited first!");
23981 const nativeResponseValue = wasm.TS_COption_U128Z_none();
23982 return nativeResponseValue;
23984 // void COption_U128Z_free(struct LDKCOption_U128Z _res);
23986 export function COption_U128Z_free(_res: bigint): void {
23987 if(!isWasmInitialized) {
23988 throw new Error("initializeWasm() must be awaited first!");
23990 const nativeResponseValue = wasm.TS_COption_U128Z_free(_res);
23991 // debug statements here
23993 // uint64_t COption_U128Z_clone_ptr(LDKCOption_U128Z *NONNULL_PTR arg);
23995 export function COption_U128Z_clone_ptr(arg: bigint): bigint {
23996 if(!isWasmInitialized) {
23997 throw new Error("initializeWasm() must be awaited first!");
23999 const nativeResponseValue = wasm.TS_COption_U128Z_clone_ptr(arg);
24000 return nativeResponseValue;
24002 // struct LDKCOption_U128Z COption_U128Z_clone(const struct LDKCOption_U128Z *NONNULL_PTR orig);
24004 export function COption_U128Z_clone(orig: bigint): bigint {
24005 if(!isWasmInitialized) {
24006 throw new Error("initializeWasm() must be awaited first!");
24008 const nativeResponseValue = wasm.TS_COption_U128Z_clone(orig);
24009 return nativeResponseValue;
24011 // void CVec_ClaimedHTLCZ_free(struct LDKCVec_ClaimedHTLCZ _res);
24013 export function CVec_ClaimedHTLCZ_free(_res: number): void {
24014 if(!isWasmInitialized) {
24015 throw new Error("initializeWasm() must be awaited first!");
24017 const nativeResponseValue = wasm.TS_CVec_ClaimedHTLCZ_free(_res);
24018 // debug statements here
24020 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_some(enum LDKPaymentFailureReason o);
24022 export function COption_PaymentFailureReasonZ_some(o: PaymentFailureReason): bigint {
24023 if(!isWasmInitialized) {
24024 throw new Error("initializeWasm() must be awaited first!");
24026 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_some(o);
24027 return nativeResponseValue;
24029 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_none(void);
24031 export function COption_PaymentFailureReasonZ_none(): bigint {
24032 if(!isWasmInitialized) {
24033 throw new Error("initializeWasm() must be awaited first!");
24035 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_none();
24036 return nativeResponseValue;
24038 // void COption_PaymentFailureReasonZ_free(struct LDKCOption_PaymentFailureReasonZ _res);
24040 export function COption_PaymentFailureReasonZ_free(_res: bigint): void {
24041 if(!isWasmInitialized) {
24042 throw new Error("initializeWasm() must be awaited first!");
24044 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_free(_res);
24045 // debug statements here
24047 // uint64_t COption_PaymentFailureReasonZ_clone_ptr(LDKCOption_PaymentFailureReasonZ *NONNULL_PTR arg);
24049 export function COption_PaymentFailureReasonZ_clone_ptr(arg: bigint): bigint {
24050 if(!isWasmInitialized) {
24051 throw new Error("initializeWasm() must be awaited first!");
24053 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone_ptr(arg);
24054 return nativeResponseValue;
24056 // struct LDKCOption_PaymentFailureReasonZ COption_PaymentFailureReasonZ_clone(const struct LDKCOption_PaymentFailureReasonZ *NONNULL_PTR orig);
24058 export function COption_PaymentFailureReasonZ_clone(orig: bigint): bigint {
24059 if(!isWasmInitialized) {
24060 throw new Error("initializeWasm() must be awaited first!");
24062 const nativeResponseValue = wasm.TS_COption_PaymentFailureReasonZ_clone(orig);
24063 return nativeResponseValue;
24065 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
24067 export function COption_EventZ_some(o: bigint): bigint {
24068 if(!isWasmInitialized) {
24069 throw new Error("initializeWasm() must be awaited first!");
24071 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
24072 return nativeResponseValue;
24074 // struct LDKCOption_EventZ COption_EventZ_none(void);
24076 export function COption_EventZ_none(): bigint {
24077 if(!isWasmInitialized) {
24078 throw new Error("initializeWasm() must be awaited first!");
24080 const nativeResponseValue = wasm.TS_COption_EventZ_none();
24081 return nativeResponseValue;
24083 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
24085 export function COption_EventZ_free(_res: bigint): void {
24086 if(!isWasmInitialized) {
24087 throw new Error("initializeWasm() must be awaited first!");
24089 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
24090 // debug statements here
24092 // uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
24094 export function COption_EventZ_clone_ptr(arg: bigint): bigint {
24095 if(!isWasmInitialized) {
24096 throw new Error("initializeWasm() must be awaited first!");
24098 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
24099 return nativeResponseValue;
24101 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
24103 export function COption_EventZ_clone(orig: bigint): bigint {
24104 if(!isWasmInitialized) {
24105 throw new Error("initializeWasm() must be awaited first!");
24107 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
24108 return nativeResponseValue;
24110 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
24112 export function CResult_COption_EventZDecodeErrorZ_ok(o: bigint): bigint {
24113 if(!isWasmInitialized) {
24114 throw new Error("initializeWasm() must be awaited first!");
24116 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
24117 return nativeResponseValue;
24119 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
24121 export function CResult_COption_EventZDecodeErrorZ_err(e: bigint): bigint {
24122 if(!isWasmInitialized) {
24123 throw new Error("initializeWasm() must be awaited first!");
24125 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
24126 return nativeResponseValue;
24128 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
24130 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: bigint): boolean {
24131 if(!isWasmInitialized) {
24132 throw new Error("initializeWasm() must be awaited first!");
24134 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
24135 return nativeResponseValue;
24137 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
24139 export function CResult_COption_EventZDecodeErrorZ_free(_res: bigint): void {
24140 if(!isWasmInitialized) {
24141 throw new Error("initializeWasm() must be awaited first!");
24143 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
24144 // debug statements here
24146 // uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
24148 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24149 if(!isWasmInitialized) {
24150 throw new Error("initializeWasm() must be awaited first!");
24152 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
24153 return nativeResponseValue;
24155 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
24157 export function CResult_COption_EventZDecodeErrorZ_clone(orig: bigint): bigint {
24158 if(!isWasmInitialized) {
24159 throw new Error("initializeWasm() must be awaited first!");
24161 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
24162 return nativeResponseValue;
24164 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_ok(enum LDKSiPrefix o);
24166 export function CResult_SiPrefixBolt11ParseErrorZ_ok(o: SiPrefix): bigint {
24167 if(!isWasmInitialized) {
24168 throw new Error("initializeWasm() must be awaited first!");
24170 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_ok(o);
24171 return nativeResponseValue;
24173 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_err(struct LDKBolt11ParseError e);
24175 export function CResult_SiPrefixBolt11ParseErrorZ_err(e: bigint): bigint {
24176 if(!isWasmInitialized) {
24177 throw new Error("initializeWasm() must be awaited first!");
24179 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_err(e);
24180 return nativeResponseValue;
24182 // bool CResult_SiPrefixBolt11ParseErrorZ_is_ok(const struct LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR o);
24184 export function CResult_SiPrefixBolt11ParseErrorZ_is_ok(o: bigint): boolean {
24185 if(!isWasmInitialized) {
24186 throw new Error("initializeWasm() must be awaited first!");
24188 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_is_ok(o);
24189 return nativeResponseValue;
24191 // void CResult_SiPrefixBolt11ParseErrorZ_free(struct LDKCResult_SiPrefixBolt11ParseErrorZ _res);
24193 export function CResult_SiPrefixBolt11ParseErrorZ_free(_res: bigint): void {
24194 if(!isWasmInitialized) {
24195 throw new Error("initializeWasm() must be awaited first!");
24197 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_free(_res);
24198 // debug statements here
24200 // uint64_t CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR arg);
24202 export function CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(arg: bigint): bigint {
24203 if(!isWasmInitialized) {
24204 throw new Error("initializeWasm() must be awaited first!");
24206 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(arg);
24207 return nativeResponseValue;
24209 // struct LDKCResult_SiPrefixBolt11ParseErrorZ CResult_SiPrefixBolt11ParseErrorZ_clone(const struct LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR orig);
24211 export function CResult_SiPrefixBolt11ParseErrorZ_clone(orig: bigint): bigint {
24212 if(!isWasmInitialized) {
24213 throw new Error("initializeWasm() must be awaited first!");
24215 const nativeResponseValue = wasm.TS_CResult_SiPrefixBolt11ParseErrorZ_clone(orig);
24216 return nativeResponseValue;
24218 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(struct LDKBolt11Invoice o);
24220 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(o: bigint): bigint {
24221 if(!isWasmInitialized) {
24222 throw new Error("initializeWasm() must be awaited first!");
24224 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(o);
24225 return nativeResponseValue;
24227 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
24229 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(e: bigint): bigint {
24230 if(!isWasmInitialized) {
24231 throw new Error("initializeWasm() must be awaited first!");
24233 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(e);
24234 return nativeResponseValue;
24236 // bool CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
24238 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(o: bigint): boolean {
24239 if(!isWasmInitialized) {
24240 throw new Error("initializeWasm() must be awaited first!");
24242 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(o);
24243 return nativeResponseValue;
24245 // void CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ _res);
24247 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(_res: bigint): void {
24248 if(!isWasmInitialized) {
24249 throw new Error("initializeWasm() must be awaited first!");
24251 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(_res);
24252 // debug statements here
24254 // uint64_t CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
24256 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(arg: bigint): bigint {
24257 if(!isWasmInitialized) {
24258 throw new Error("initializeWasm() must be awaited first!");
24260 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
24261 return nativeResponseValue;
24263 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
24265 export function CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(orig: bigint): bigint {
24266 if(!isWasmInitialized) {
24267 throw new Error("initializeWasm() must be awaited first!");
24269 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(orig);
24270 return nativeResponseValue;
24272 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(struct LDKSignedRawBolt11Invoice o);
24274 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(o: bigint): bigint {
24275 if(!isWasmInitialized) {
24276 throw new Error("initializeWasm() must be awaited first!");
24278 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(o);
24279 return nativeResponseValue;
24281 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(struct LDKBolt11ParseError e);
24283 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(e: bigint): bigint {
24284 if(!isWasmInitialized) {
24285 throw new Error("initializeWasm() must be awaited first!");
24287 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(e);
24288 return nativeResponseValue;
24290 // bool CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(const struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR o);
24292 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(o: bigint): boolean {
24293 if(!isWasmInitialized) {
24294 throw new Error("initializeWasm() must be awaited first!");
24296 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(o);
24297 return nativeResponseValue;
24299 // void CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ _res);
24301 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(_res: bigint): void {
24302 if(!isWasmInitialized) {
24303 throw new Error("initializeWasm() must be awaited first!");
24305 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(_res);
24306 // debug statements here
24308 // uint64_t CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR arg);
24310 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(arg: bigint): bigint {
24311 if(!isWasmInitialized) {
24312 throw new Error("initializeWasm() must be awaited first!");
24314 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(arg);
24315 return nativeResponseValue;
24317 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(const struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR orig);
24319 export function CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(orig: bigint): bigint {
24320 if(!isWasmInitialized) {
24321 throw new Error("initializeWasm() must be awaited first!");
24323 const nativeResponseValue = wasm.TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(orig);
24324 return nativeResponseValue;
24326 // uint64_t C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR arg);
24328 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(arg: bigint): bigint {
24329 if(!isWasmInitialized) {
24330 throw new Error("initializeWasm() must be awaited first!");
24332 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(arg);
24333 return nativeResponseValue;
24335 // struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR orig);
24337 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(orig: bigint): bigint {
24338 if(!isWasmInitialized) {
24339 throw new Error("initializeWasm() must be awaited first!");
24341 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(orig);
24342 return nativeResponseValue;
24344 // struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(struct LDKRawBolt11Invoice a, struct LDKThirtyTwoBytes b, struct LDKBolt11InvoiceSignature c);
24346 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(a: bigint, b: number, c: bigint): bigint {
24347 if(!isWasmInitialized) {
24348 throw new Error("initializeWasm() must be awaited first!");
24350 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(a, b, c);
24351 return nativeResponseValue;
24353 // void C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ _res);
24355 export function C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(_res: bigint): void {
24356 if(!isWasmInitialized) {
24357 throw new Error("initializeWasm() must be awaited first!");
24359 const nativeResponseValue = wasm.TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(_res);
24360 // debug statements here
24362 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_ok(struct LDKPayeePubKey o);
24364 export function CResult_PayeePubKeySecp256k1ErrorZ_ok(o: bigint): bigint {
24365 if(!isWasmInitialized) {
24366 throw new Error("initializeWasm() must be awaited first!");
24368 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_ok(o);
24369 return nativeResponseValue;
24371 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
24373 export function CResult_PayeePubKeySecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
24374 if(!isWasmInitialized) {
24375 throw new Error("initializeWasm() must be awaited first!");
24377 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_err(e);
24378 return nativeResponseValue;
24380 // bool CResult_PayeePubKeySecp256k1ErrorZ_is_ok(const struct LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR o);
24382 export function CResult_PayeePubKeySecp256k1ErrorZ_is_ok(o: bigint): boolean {
24383 if(!isWasmInitialized) {
24384 throw new Error("initializeWasm() must be awaited first!");
24386 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_is_ok(o);
24387 return nativeResponseValue;
24389 // void CResult_PayeePubKeySecp256k1ErrorZ_free(struct LDKCResult_PayeePubKeySecp256k1ErrorZ _res);
24391 export function CResult_PayeePubKeySecp256k1ErrorZ_free(_res: bigint): void {
24392 if(!isWasmInitialized) {
24393 throw new Error("initializeWasm() must be awaited first!");
24395 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_free(_res);
24396 // debug statements here
24398 // uint64_t CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR arg);
24400 export function CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
24401 if(!isWasmInitialized) {
24402 throw new Error("initializeWasm() must be awaited first!");
24404 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(arg);
24405 return nativeResponseValue;
24407 // struct LDKCResult_PayeePubKeySecp256k1ErrorZ CResult_PayeePubKeySecp256k1ErrorZ_clone(const struct LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR orig);
24409 export function CResult_PayeePubKeySecp256k1ErrorZ_clone(orig: bigint): bigint {
24410 if(!isWasmInitialized) {
24411 throw new Error("initializeWasm() must be awaited first!");
24413 const nativeResponseValue = wasm.TS_CResult_PayeePubKeySecp256k1ErrorZ_clone(orig);
24414 return nativeResponseValue;
24416 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
24418 export function CVec_PrivateRouteZ_free(_res: number): void {
24419 if(!isWasmInitialized) {
24420 throw new Error("initializeWasm() must be awaited first!");
24422 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
24423 // debug statements here
24425 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
24427 export function CResult_PositiveTimestampCreationErrorZ_ok(o: bigint): bigint {
24428 if(!isWasmInitialized) {
24429 throw new Error("initializeWasm() must be awaited first!");
24431 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
24432 return nativeResponseValue;
24434 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
24436 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): bigint {
24437 if(!isWasmInitialized) {
24438 throw new Error("initializeWasm() must be awaited first!");
24440 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
24441 return nativeResponseValue;
24443 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
24445 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: bigint): boolean {
24446 if(!isWasmInitialized) {
24447 throw new Error("initializeWasm() must be awaited first!");
24449 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
24450 return nativeResponseValue;
24452 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
24454 export function CResult_PositiveTimestampCreationErrorZ_free(_res: bigint): void {
24455 if(!isWasmInitialized) {
24456 throw new Error("initializeWasm() must be awaited first!");
24458 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
24459 // debug statements here
24461 // uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
24463 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: bigint): bigint {
24464 if(!isWasmInitialized) {
24465 throw new Error("initializeWasm() must be awaited first!");
24467 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
24468 return nativeResponseValue;
24470 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
24472 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: bigint): bigint {
24473 if(!isWasmInitialized) {
24474 throw new Error("initializeWasm() must be awaited first!");
24476 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
24477 return nativeResponseValue;
24479 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_ok(void);
24481 export function CResult_NoneBolt11SemanticErrorZ_ok(): bigint {
24482 if(!isWasmInitialized) {
24483 throw new Error("initializeWasm() must be awaited first!");
24485 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_ok();
24486 return nativeResponseValue;
24488 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_err(enum LDKBolt11SemanticError e);
24490 export function CResult_NoneBolt11SemanticErrorZ_err(e: Bolt11SemanticError): bigint {
24491 if(!isWasmInitialized) {
24492 throw new Error("initializeWasm() must be awaited first!");
24494 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_err(e);
24495 return nativeResponseValue;
24497 // bool CResult_NoneBolt11SemanticErrorZ_is_ok(const struct LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR o);
24499 export function CResult_NoneBolt11SemanticErrorZ_is_ok(o: bigint): boolean {
24500 if(!isWasmInitialized) {
24501 throw new Error("initializeWasm() must be awaited first!");
24503 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_is_ok(o);
24504 return nativeResponseValue;
24506 // void CResult_NoneBolt11SemanticErrorZ_free(struct LDKCResult_NoneBolt11SemanticErrorZ _res);
24508 export function CResult_NoneBolt11SemanticErrorZ_free(_res: bigint): void {
24509 if(!isWasmInitialized) {
24510 throw new Error("initializeWasm() must be awaited first!");
24512 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_free(_res);
24513 // debug statements here
24515 // uint64_t CResult_NoneBolt11SemanticErrorZ_clone_ptr(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR arg);
24517 export function CResult_NoneBolt11SemanticErrorZ_clone_ptr(arg: bigint): bigint {
24518 if(!isWasmInitialized) {
24519 throw new Error("initializeWasm() must be awaited first!");
24521 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_clone_ptr(arg);
24522 return nativeResponseValue;
24524 // struct LDKCResult_NoneBolt11SemanticErrorZ CResult_NoneBolt11SemanticErrorZ_clone(const struct LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR orig);
24526 export function CResult_NoneBolt11SemanticErrorZ_clone(orig: bigint): bigint {
24527 if(!isWasmInitialized) {
24528 throw new Error("initializeWasm() must be awaited first!");
24530 const nativeResponseValue = wasm.TS_CResult_NoneBolt11SemanticErrorZ_clone(orig);
24531 return nativeResponseValue;
24533 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(struct LDKBolt11Invoice o);
24535 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(o: bigint): bigint {
24536 if(!isWasmInitialized) {
24537 throw new Error("initializeWasm() must be awaited first!");
24539 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(o);
24540 return nativeResponseValue;
24542 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(enum LDKBolt11SemanticError e);
24544 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(e: Bolt11SemanticError): bigint {
24545 if(!isWasmInitialized) {
24546 throw new Error("initializeWasm() must be awaited first!");
24548 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(e);
24549 return nativeResponseValue;
24551 // bool CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(const struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR o);
24553 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(o: bigint): boolean {
24554 if(!isWasmInitialized) {
24555 throw new Error("initializeWasm() must be awaited first!");
24557 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(o);
24558 return nativeResponseValue;
24560 // void CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ _res);
24562 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(_res: bigint): void {
24563 if(!isWasmInitialized) {
24564 throw new Error("initializeWasm() must be awaited first!");
24566 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(_res);
24567 // debug statements here
24569 // uint64_t CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR arg);
24571 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(arg: bigint): bigint {
24572 if(!isWasmInitialized) {
24573 throw new Error("initializeWasm() must be awaited first!");
24575 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(arg);
24576 return nativeResponseValue;
24578 // struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(const struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR orig);
24580 export function CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(orig: bigint): bigint {
24581 if(!isWasmInitialized) {
24582 throw new Error("initializeWasm() must be awaited first!");
24584 const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(orig);
24585 return nativeResponseValue;
24587 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
24589 export function CResult_DescriptionCreationErrorZ_ok(o: bigint): bigint {
24590 if(!isWasmInitialized) {
24591 throw new Error("initializeWasm() must be awaited first!");
24593 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
24594 return nativeResponseValue;
24596 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
24598 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): bigint {
24599 if(!isWasmInitialized) {
24600 throw new Error("initializeWasm() must be awaited first!");
24602 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
24603 return nativeResponseValue;
24605 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
24607 export function CResult_DescriptionCreationErrorZ_is_ok(o: bigint): boolean {
24608 if(!isWasmInitialized) {
24609 throw new Error("initializeWasm() must be awaited first!");
24611 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
24612 return nativeResponseValue;
24614 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
24616 export function CResult_DescriptionCreationErrorZ_free(_res: bigint): void {
24617 if(!isWasmInitialized) {
24618 throw new Error("initializeWasm() must be awaited first!");
24620 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
24621 // debug statements here
24623 // uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
24625 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: bigint): bigint {
24626 if(!isWasmInitialized) {
24627 throw new Error("initializeWasm() must be awaited first!");
24629 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
24630 return nativeResponseValue;
24632 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
24634 export function CResult_DescriptionCreationErrorZ_clone(orig: bigint): bigint {
24635 if(!isWasmInitialized) {
24636 throw new Error("initializeWasm() must be awaited first!");
24638 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
24639 return nativeResponseValue;
24641 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
24643 export function CResult_PrivateRouteCreationErrorZ_ok(o: bigint): bigint {
24644 if(!isWasmInitialized) {
24645 throw new Error("initializeWasm() must be awaited first!");
24647 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
24648 return nativeResponseValue;
24650 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
24652 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): bigint {
24653 if(!isWasmInitialized) {
24654 throw new Error("initializeWasm() must be awaited first!");
24656 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
24657 return nativeResponseValue;
24659 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
24661 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: bigint): boolean {
24662 if(!isWasmInitialized) {
24663 throw new Error("initializeWasm() must be awaited first!");
24665 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
24666 return nativeResponseValue;
24668 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
24670 export function CResult_PrivateRouteCreationErrorZ_free(_res: bigint): void {
24671 if(!isWasmInitialized) {
24672 throw new Error("initializeWasm() must be awaited first!");
24674 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
24675 // debug statements here
24677 // uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
24679 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: bigint): bigint {
24680 if(!isWasmInitialized) {
24681 throw new Error("initializeWasm() must be awaited first!");
24683 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
24684 return nativeResponseValue;
24686 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
24688 export function CResult_PrivateRouteCreationErrorZ_clone(orig: bigint): bigint {
24689 if(!isWasmInitialized) {
24690 throw new Error("initializeWasm() must be awaited first!");
24692 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
24693 return nativeResponseValue;
24695 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
24697 export function CResult_OutPointDecodeErrorZ_ok(o: bigint): bigint {
24698 if(!isWasmInitialized) {
24699 throw new Error("initializeWasm() must be awaited first!");
24701 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
24702 return nativeResponseValue;
24704 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
24706 export function CResult_OutPointDecodeErrorZ_err(e: bigint): bigint {
24707 if(!isWasmInitialized) {
24708 throw new Error("initializeWasm() must be awaited first!");
24710 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
24711 return nativeResponseValue;
24713 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
24715 export function CResult_OutPointDecodeErrorZ_is_ok(o: bigint): boolean {
24716 if(!isWasmInitialized) {
24717 throw new Error("initializeWasm() must be awaited first!");
24719 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
24720 return nativeResponseValue;
24722 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
24724 export function CResult_OutPointDecodeErrorZ_free(_res: bigint): void {
24725 if(!isWasmInitialized) {
24726 throw new Error("initializeWasm() must be awaited first!");
24728 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
24729 // debug statements here
24731 // uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
24733 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24734 if(!isWasmInitialized) {
24735 throw new Error("initializeWasm() must be awaited first!");
24737 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
24738 return nativeResponseValue;
24740 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
24742 export function CResult_OutPointDecodeErrorZ_clone(orig: bigint): bigint {
24743 if(!isWasmInitialized) {
24744 throw new Error("initializeWasm() must be awaited first!");
24746 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
24747 return nativeResponseValue;
24749 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_ok(struct LDKBigSize o);
24751 export function CResult_BigSizeDecodeErrorZ_ok(o: bigint): bigint {
24752 if(!isWasmInitialized) {
24753 throw new Error("initializeWasm() must be awaited first!");
24755 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_ok(o);
24756 return nativeResponseValue;
24758 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_err(struct LDKDecodeError e);
24760 export function CResult_BigSizeDecodeErrorZ_err(e: bigint): bigint {
24761 if(!isWasmInitialized) {
24762 throw new Error("initializeWasm() must be awaited first!");
24764 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_err(e);
24765 return nativeResponseValue;
24767 // bool CResult_BigSizeDecodeErrorZ_is_ok(const struct LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR o);
24769 export function CResult_BigSizeDecodeErrorZ_is_ok(o: bigint): boolean {
24770 if(!isWasmInitialized) {
24771 throw new Error("initializeWasm() must be awaited first!");
24773 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_is_ok(o);
24774 return nativeResponseValue;
24776 // void CResult_BigSizeDecodeErrorZ_free(struct LDKCResult_BigSizeDecodeErrorZ _res);
24778 export function CResult_BigSizeDecodeErrorZ_free(_res: bigint): void {
24779 if(!isWasmInitialized) {
24780 throw new Error("initializeWasm() must be awaited first!");
24782 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_free(_res);
24783 // debug statements here
24785 // uint64_t CResult_BigSizeDecodeErrorZ_clone_ptr(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR arg);
24787 export function CResult_BigSizeDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24788 if(!isWasmInitialized) {
24789 throw new Error("initializeWasm() must be awaited first!");
24791 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_clone_ptr(arg);
24792 return nativeResponseValue;
24794 // struct LDKCResult_BigSizeDecodeErrorZ CResult_BigSizeDecodeErrorZ_clone(const struct LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR orig);
24796 export function CResult_BigSizeDecodeErrorZ_clone(orig: bigint): bigint {
24797 if(!isWasmInitialized) {
24798 throw new Error("initializeWasm() must be awaited first!");
24800 const nativeResponseValue = wasm.TS_CResult_BigSizeDecodeErrorZ_clone(orig);
24801 return nativeResponseValue;
24803 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_ok(struct LDKHostname o);
24805 export function CResult_HostnameDecodeErrorZ_ok(o: bigint): bigint {
24806 if(!isWasmInitialized) {
24807 throw new Error("initializeWasm() must be awaited first!");
24809 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_ok(o);
24810 return nativeResponseValue;
24812 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_err(struct LDKDecodeError e);
24814 export function CResult_HostnameDecodeErrorZ_err(e: bigint): bigint {
24815 if(!isWasmInitialized) {
24816 throw new Error("initializeWasm() must be awaited first!");
24818 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_err(e);
24819 return nativeResponseValue;
24821 // bool CResult_HostnameDecodeErrorZ_is_ok(const struct LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR o);
24823 export function CResult_HostnameDecodeErrorZ_is_ok(o: bigint): boolean {
24824 if(!isWasmInitialized) {
24825 throw new Error("initializeWasm() must be awaited first!");
24827 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_is_ok(o);
24828 return nativeResponseValue;
24830 // void CResult_HostnameDecodeErrorZ_free(struct LDKCResult_HostnameDecodeErrorZ _res);
24832 export function CResult_HostnameDecodeErrorZ_free(_res: bigint): void {
24833 if(!isWasmInitialized) {
24834 throw new Error("initializeWasm() must be awaited first!");
24836 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_free(_res);
24837 // debug statements here
24839 // uint64_t CResult_HostnameDecodeErrorZ_clone_ptr(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR arg);
24841 export function CResult_HostnameDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24842 if(!isWasmInitialized) {
24843 throw new Error("initializeWasm() must be awaited first!");
24845 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_clone_ptr(arg);
24846 return nativeResponseValue;
24848 // struct LDKCResult_HostnameDecodeErrorZ CResult_HostnameDecodeErrorZ_clone(const struct LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR orig);
24850 export function CResult_HostnameDecodeErrorZ_clone(orig: bigint): bigint {
24851 if(!isWasmInitialized) {
24852 throw new Error("initializeWasm() must be awaited first!");
24854 const nativeResponseValue = wasm.TS_CResult_HostnameDecodeErrorZ_clone(orig);
24855 return nativeResponseValue;
24857 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_ok(struct LDKTransactionU16LenLimited o);
24859 export function CResult_TransactionU16LenLimitedNoneZ_ok(o: bigint): bigint {
24860 if(!isWasmInitialized) {
24861 throw new Error("initializeWasm() must be awaited first!");
24863 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_ok(o);
24864 return nativeResponseValue;
24866 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_err(void);
24868 export function CResult_TransactionU16LenLimitedNoneZ_err(): bigint {
24869 if(!isWasmInitialized) {
24870 throw new Error("initializeWasm() must be awaited first!");
24872 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_err();
24873 return nativeResponseValue;
24875 // bool CResult_TransactionU16LenLimitedNoneZ_is_ok(const struct LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR o);
24877 export function CResult_TransactionU16LenLimitedNoneZ_is_ok(o: bigint): boolean {
24878 if(!isWasmInitialized) {
24879 throw new Error("initializeWasm() must be awaited first!");
24881 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_is_ok(o);
24882 return nativeResponseValue;
24884 // void CResult_TransactionU16LenLimitedNoneZ_free(struct LDKCResult_TransactionU16LenLimitedNoneZ _res);
24886 export function CResult_TransactionU16LenLimitedNoneZ_free(_res: bigint): void {
24887 if(!isWasmInitialized) {
24888 throw new Error("initializeWasm() must be awaited first!");
24890 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_free(_res);
24891 // debug statements here
24893 // uint64_t CResult_TransactionU16LenLimitedNoneZ_clone_ptr(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR arg);
24895 export function CResult_TransactionU16LenLimitedNoneZ_clone_ptr(arg: bigint): bigint {
24896 if(!isWasmInitialized) {
24897 throw new Error("initializeWasm() must be awaited first!");
24899 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_clone_ptr(arg);
24900 return nativeResponseValue;
24902 // struct LDKCResult_TransactionU16LenLimitedNoneZ CResult_TransactionU16LenLimitedNoneZ_clone(const struct LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR orig);
24904 export function CResult_TransactionU16LenLimitedNoneZ_clone(orig: bigint): bigint {
24905 if(!isWasmInitialized) {
24906 throw new Error("initializeWasm() must be awaited first!");
24908 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedNoneZ_clone(orig);
24909 return nativeResponseValue;
24911 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_ok(struct LDKTransactionU16LenLimited o);
24913 export function CResult_TransactionU16LenLimitedDecodeErrorZ_ok(o: bigint): bigint {
24914 if(!isWasmInitialized) {
24915 throw new Error("initializeWasm() must be awaited first!");
24917 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_ok(o);
24918 return nativeResponseValue;
24920 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_err(struct LDKDecodeError e);
24922 export function CResult_TransactionU16LenLimitedDecodeErrorZ_err(e: bigint): bigint {
24923 if(!isWasmInitialized) {
24924 throw new Error("initializeWasm() must be awaited first!");
24926 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_err(e);
24927 return nativeResponseValue;
24929 // bool CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(const struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR o);
24931 export function CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(o: bigint): boolean {
24932 if(!isWasmInitialized) {
24933 throw new Error("initializeWasm() must be awaited first!");
24935 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(o);
24936 return nativeResponseValue;
24938 // void CResult_TransactionU16LenLimitedDecodeErrorZ_free(struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ _res);
24940 export function CResult_TransactionU16LenLimitedDecodeErrorZ_free(_res: bigint): void {
24941 if(!isWasmInitialized) {
24942 throw new Error("initializeWasm() must be awaited first!");
24944 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_free(_res);
24945 // debug statements here
24947 // uint64_t CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR arg);
24949 export function CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(arg: bigint): bigint {
24950 if(!isWasmInitialized) {
24951 throw new Error("initializeWasm() must be awaited first!");
24953 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(arg);
24954 return nativeResponseValue;
24956 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ CResult_TransactionU16LenLimitedDecodeErrorZ_clone(const struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR orig);
24958 export function CResult_TransactionU16LenLimitedDecodeErrorZ_clone(orig: bigint): bigint {
24959 if(!isWasmInitialized) {
24960 throw new Error("initializeWasm() must be awaited first!");
24962 const nativeResponseValue = wasm.TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone(orig);
24963 return nativeResponseValue;
24965 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_ok(struct LDKUntrustedString o);
24967 export function CResult_UntrustedStringDecodeErrorZ_ok(o: bigint): bigint {
24968 if(!isWasmInitialized) {
24969 throw new Error("initializeWasm() must be awaited first!");
24971 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_ok(o);
24972 return nativeResponseValue;
24974 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_err(struct LDKDecodeError e);
24976 export function CResult_UntrustedStringDecodeErrorZ_err(e: bigint): bigint {
24977 if(!isWasmInitialized) {
24978 throw new Error("initializeWasm() must be awaited first!");
24980 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_err(e);
24981 return nativeResponseValue;
24983 // bool CResult_UntrustedStringDecodeErrorZ_is_ok(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR o);
24985 export function CResult_UntrustedStringDecodeErrorZ_is_ok(o: bigint): boolean {
24986 if(!isWasmInitialized) {
24987 throw new Error("initializeWasm() must be awaited first!");
24989 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_is_ok(o);
24990 return nativeResponseValue;
24992 // void CResult_UntrustedStringDecodeErrorZ_free(struct LDKCResult_UntrustedStringDecodeErrorZ _res);
24994 export function CResult_UntrustedStringDecodeErrorZ_free(_res: bigint): void {
24995 if(!isWasmInitialized) {
24996 throw new Error("initializeWasm() must be awaited first!");
24998 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_free(_res);
24999 // debug statements here
25001 // uint64_t CResult_UntrustedStringDecodeErrorZ_clone_ptr(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR arg);
25003 export function CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25004 if(!isWasmInitialized) {
25005 throw new Error("initializeWasm() must be awaited first!");
25007 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg);
25008 return nativeResponseValue;
25010 // struct LDKCResult_UntrustedStringDecodeErrorZ CResult_UntrustedStringDecodeErrorZ_clone(const struct LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR orig);
25012 export function CResult_UntrustedStringDecodeErrorZ_clone(orig: bigint): bigint {
25013 if(!isWasmInitialized) {
25014 throw new Error("initializeWasm() must be awaited first!");
25016 const nativeResponseValue = wasm.TS_CResult_UntrustedStringDecodeErrorZ_clone(orig);
25017 return nativeResponseValue;
25019 // uint64_t C2Tuple__u832u16Z_clone_ptr(LDKC2Tuple__u832u16Z *NONNULL_PTR arg);
25021 export function C2Tuple__u832u16Z_clone_ptr(arg: bigint): bigint {
25022 if(!isWasmInitialized) {
25023 throw new Error("initializeWasm() must be awaited first!");
25025 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_clone_ptr(arg);
25026 return nativeResponseValue;
25028 // struct LDKC2Tuple__u832u16Z C2Tuple__u832u16Z_clone(const struct LDKC2Tuple__u832u16Z *NONNULL_PTR orig);
25030 export function C2Tuple__u832u16Z_clone(orig: bigint): bigint {
25031 if(!isWasmInitialized) {
25032 throw new Error("initializeWasm() must be awaited first!");
25034 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_clone(orig);
25035 return nativeResponseValue;
25037 // struct LDKC2Tuple__u832u16Z C2Tuple__u832u16Z_new(struct LDKThirtyTwoBytes a, uint16_t b);
25039 export function C2Tuple__u832u16Z_new(a: number, b: number): bigint {
25040 if(!isWasmInitialized) {
25041 throw new Error("initializeWasm() must be awaited first!");
25043 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_new(a, b);
25044 return nativeResponseValue;
25046 // void C2Tuple__u832u16Z_free(struct LDKC2Tuple__u832u16Z _res);
25048 export function C2Tuple__u832u16Z_free(_res: bigint): void {
25049 if(!isWasmInitialized) {
25050 throw new Error("initializeWasm() must be awaited first!");
25052 const nativeResponseValue = wasm.TS_C2Tuple__u832u16Z_free(_res);
25053 // debug statements here
25055 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_ok(struct LDKPaymentRelay o);
25057 export function CResult_PaymentRelayDecodeErrorZ_ok(o: bigint): bigint {
25058 if(!isWasmInitialized) {
25059 throw new Error("initializeWasm() must be awaited first!");
25061 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_ok(o);
25062 return nativeResponseValue;
25064 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_err(struct LDKDecodeError e);
25066 export function CResult_PaymentRelayDecodeErrorZ_err(e: bigint): bigint {
25067 if(!isWasmInitialized) {
25068 throw new Error("initializeWasm() must be awaited first!");
25070 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_err(e);
25071 return nativeResponseValue;
25073 // bool CResult_PaymentRelayDecodeErrorZ_is_ok(const struct LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR o);
25075 export function CResult_PaymentRelayDecodeErrorZ_is_ok(o: bigint): boolean {
25076 if(!isWasmInitialized) {
25077 throw new Error("initializeWasm() must be awaited first!");
25079 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_is_ok(o);
25080 return nativeResponseValue;
25082 // void CResult_PaymentRelayDecodeErrorZ_free(struct LDKCResult_PaymentRelayDecodeErrorZ _res);
25084 export function CResult_PaymentRelayDecodeErrorZ_free(_res: bigint): void {
25085 if(!isWasmInitialized) {
25086 throw new Error("initializeWasm() must be awaited first!");
25088 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_free(_res);
25089 // debug statements here
25091 // uint64_t CResult_PaymentRelayDecodeErrorZ_clone_ptr(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR arg);
25093 export function CResult_PaymentRelayDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25094 if(!isWasmInitialized) {
25095 throw new Error("initializeWasm() must be awaited first!");
25097 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_clone_ptr(arg);
25098 return nativeResponseValue;
25100 // struct LDKCResult_PaymentRelayDecodeErrorZ CResult_PaymentRelayDecodeErrorZ_clone(const struct LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR orig);
25102 export function CResult_PaymentRelayDecodeErrorZ_clone(orig: bigint): bigint {
25103 if(!isWasmInitialized) {
25104 throw new Error("initializeWasm() must be awaited first!");
25106 const nativeResponseValue = wasm.TS_CResult_PaymentRelayDecodeErrorZ_clone(orig);
25107 return nativeResponseValue;
25109 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_ok(struct LDKPaymentConstraints o);
25111 export function CResult_PaymentConstraintsDecodeErrorZ_ok(o: bigint): bigint {
25112 if(!isWasmInitialized) {
25113 throw new Error("initializeWasm() must be awaited first!");
25115 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_ok(o);
25116 return nativeResponseValue;
25118 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_err(struct LDKDecodeError e);
25120 export function CResult_PaymentConstraintsDecodeErrorZ_err(e: bigint): bigint {
25121 if(!isWasmInitialized) {
25122 throw new Error("initializeWasm() must be awaited first!");
25124 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_err(e);
25125 return nativeResponseValue;
25127 // bool CResult_PaymentConstraintsDecodeErrorZ_is_ok(const struct LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR o);
25129 export function CResult_PaymentConstraintsDecodeErrorZ_is_ok(o: bigint): boolean {
25130 if(!isWasmInitialized) {
25131 throw new Error("initializeWasm() must be awaited first!");
25133 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_is_ok(o);
25134 return nativeResponseValue;
25136 // void CResult_PaymentConstraintsDecodeErrorZ_free(struct LDKCResult_PaymentConstraintsDecodeErrorZ _res);
25138 export function CResult_PaymentConstraintsDecodeErrorZ_free(_res: bigint): void {
25139 if(!isWasmInitialized) {
25140 throw new Error("initializeWasm() must be awaited first!");
25142 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_free(_res);
25143 // debug statements here
25145 // uint64_t CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR arg);
25147 export function CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25148 if(!isWasmInitialized) {
25149 throw new Error("initializeWasm() must be awaited first!");
25151 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(arg);
25152 return nativeResponseValue;
25154 // struct LDKCResult_PaymentConstraintsDecodeErrorZ CResult_PaymentConstraintsDecodeErrorZ_clone(const struct LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR orig);
25156 export function CResult_PaymentConstraintsDecodeErrorZ_clone(orig: bigint): bigint {
25157 if(!isWasmInitialized) {
25158 throw new Error("initializeWasm() must be awaited first!");
25160 const nativeResponseValue = wasm.TS_CResult_PaymentConstraintsDecodeErrorZ_clone(orig);
25161 return nativeResponseValue;
25163 // uint64_t C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone_ptr(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR arg);
25165 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone_ptr(arg: bigint): bigint {
25166 if(!isWasmInitialized) {
25167 throw new Error("initializeWasm() must be awaited first!");
25169 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone_ptr(arg);
25170 return nativeResponseValue;
25172 // struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone(const struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR orig);
25174 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone(orig: bigint): bigint {
25175 if(!isWasmInitialized) {
25176 throw new Error("initializeWasm() must be awaited first!");
25178 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_clone(orig);
25179 return nativeResponseValue;
25181 // struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_new(struct LDKThirtyTwoBytes a, struct LDKRecipientOnionFields b, struct LDKRouteParameters c);
25183 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_new(a: number, b: bigint, c: bigint): bigint {
25184 if(!isWasmInitialized) {
25185 throw new Error("initializeWasm() must be awaited first!");
25187 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_new(a, b, c);
25188 return nativeResponseValue;
25190 // void C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ _res);
25192 export function C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(_res: bigint): void {
25193 if(!isWasmInitialized) {
25194 throw new Error("initializeWasm() must be awaited first!");
25196 const nativeResponseValue = wasm.TS_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(_res);
25197 // debug statements here
25199 // struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_ok(struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ o);
25201 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_ok(o: bigint): bigint {
25202 if(!isWasmInitialized) {
25203 throw new Error("initializeWasm() must be awaited first!");
25205 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_ok(o);
25206 return nativeResponseValue;
25208 // struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_err(void);
25210 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_err(): bigint {
25211 if(!isWasmInitialized) {
25212 throw new Error("initializeWasm() must be awaited first!");
25214 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_err();
25215 return nativeResponseValue;
25217 // bool CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_is_ok(const struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR o);
25219 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_is_ok(o: bigint): boolean {
25220 if(!isWasmInitialized) {
25221 throw new Error("initializeWasm() must be awaited first!");
25223 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_is_ok(o);
25224 return nativeResponseValue;
25226 // void CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ _res);
25228 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(_res: bigint): void {
25229 if(!isWasmInitialized) {
25230 throw new Error("initializeWasm() must be awaited first!");
25232 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(_res);
25233 // debug statements here
25235 // uint64_t CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone_ptr(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR arg);
25237 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone_ptr(arg: bigint): bigint {
25238 if(!isWasmInitialized) {
25239 throw new Error("initializeWasm() must be awaited first!");
25241 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone_ptr(arg);
25242 return nativeResponseValue;
25244 // struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone(const struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR orig);
25246 export function CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone(orig: bigint): bigint {
25247 if(!isWasmInitialized) {
25248 throw new Error("initializeWasm() must be awaited first!");
25250 const nativeResponseValue = wasm.TS_CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_clone(orig);
25251 return nativeResponseValue;
25253 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_ok(struct LDKStr o);
25255 export function CResult_StrSecp256k1ErrorZ_ok(o: number): bigint {
25256 if(!isWasmInitialized) {
25257 throw new Error("initializeWasm() must be awaited first!");
25259 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_ok(o);
25260 return nativeResponseValue;
25262 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_err(enum LDKSecp256k1Error e);
25264 export function CResult_StrSecp256k1ErrorZ_err(e: Secp256k1Error): bigint {
25265 if(!isWasmInitialized) {
25266 throw new Error("initializeWasm() must be awaited first!");
25268 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_err(e);
25269 return nativeResponseValue;
25271 // bool CResult_StrSecp256k1ErrorZ_is_ok(const struct LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR o);
25273 export function CResult_StrSecp256k1ErrorZ_is_ok(o: bigint): boolean {
25274 if(!isWasmInitialized) {
25275 throw new Error("initializeWasm() must be awaited first!");
25277 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_is_ok(o);
25278 return nativeResponseValue;
25280 // void CResult_StrSecp256k1ErrorZ_free(struct LDKCResult_StrSecp256k1ErrorZ _res);
25282 export function CResult_StrSecp256k1ErrorZ_free(_res: bigint): void {
25283 if(!isWasmInitialized) {
25284 throw new Error("initializeWasm() must be awaited first!");
25286 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_free(_res);
25287 // debug statements here
25289 // uint64_t CResult_StrSecp256k1ErrorZ_clone_ptr(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR arg);
25291 export function CResult_StrSecp256k1ErrorZ_clone_ptr(arg: bigint): bigint {
25292 if(!isWasmInitialized) {
25293 throw new Error("initializeWasm() must be awaited first!");
25295 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_clone_ptr(arg);
25296 return nativeResponseValue;
25298 // struct LDKCResult_StrSecp256k1ErrorZ CResult_StrSecp256k1ErrorZ_clone(const struct LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR orig);
25300 export function CResult_StrSecp256k1ErrorZ_clone(orig: bigint): bigint {
25301 if(!isWasmInitialized) {
25302 throw new Error("initializeWasm() must be awaited first!");
25304 const nativeResponseValue = wasm.TS_CResult_StrSecp256k1ErrorZ_clone(orig);
25305 return nativeResponseValue;
25307 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_ok(struct LDKTxOut o);
25309 export function CResult_TxOutUtxoLookupErrorZ_ok(o: bigint): bigint {
25310 if(!isWasmInitialized) {
25311 throw new Error("initializeWasm() must be awaited first!");
25313 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_ok(o);
25314 return nativeResponseValue;
25316 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_err(enum LDKUtxoLookupError e);
25318 export function CResult_TxOutUtxoLookupErrorZ_err(e: UtxoLookupError): bigint {
25319 if(!isWasmInitialized) {
25320 throw new Error("initializeWasm() must be awaited first!");
25322 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_err(e);
25323 return nativeResponseValue;
25325 // bool CResult_TxOutUtxoLookupErrorZ_is_ok(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR o);
25327 export function CResult_TxOutUtxoLookupErrorZ_is_ok(o: bigint): boolean {
25328 if(!isWasmInitialized) {
25329 throw new Error("initializeWasm() must be awaited first!");
25331 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_is_ok(o);
25332 return nativeResponseValue;
25334 // void CResult_TxOutUtxoLookupErrorZ_free(struct LDKCResult_TxOutUtxoLookupErrorZ _res);
25336 export function CResult_TxOutUtxoLookupErrorZ_free(_res: bigint): void {
25337 if(!isWasmInitialized) {
25338 throw new Error("initializeWasm() must be awaited first!");
25340 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_free(_res);
25341 // debug statements here
25343 // uint64_t CResult_TxOutUtxoLookupErrorZ_clone_ptr(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR arg);
25345 export function CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg: bigint): bigint {
25346 if(!isWasmInitialized) {
25347 throw new Error("initializeWasm() must be awaited first!");
25349 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg);
25350 return nativeResponseValue;
25352 // struct LDKCResult_TxOutUtxoLookupErrorZ CResult_TxOutUtxoLookupErrorZ_clone(const struct LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR orig);
25354 export function CResult_TxOutUtxoLookupErrorZ_clone(orig: bigint): bigint {
25355 if(!isWasmInitialized) {
25356 throw new Error("initializeWasm() must be awaited first!");
25358 const nativeResponseValue = wasm.TS_CResult_TxOutUtxoLookupErrorZ_clone(orig);
25359 return nativeResponseValue;
25361 // uint64_t C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone_ptr(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR arg);
25363 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone_ptr(arg: bigint): bigint {
25364 if(!isWasmInitialized) {
25365 throw new Error("initializeWasm() must be awaited first!");
25367 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone_ptr(arg);
25368 return nativeResponseValue;
25370 // struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone(const struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR orig);
25372 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone(orig: bigint): bigint {
25373 if(!isWasmInitialized) {
25374 throw new Error("initializeWasm() must be awaited first!");
25376 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_clone(orig);
25377 return nativeResponseValue;
25379 // struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_new(struct LDKPublicKey a, struct LDKOnionMessage b, struct LDKCOption_CVec_SocketAddressZZ c);
25381 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_new(a: number, b: bigint, c: bigint): bigint {
25382 if(!isWasmInitialized) {
25383 throw new Error("initializeWasm() must be awaited first!");
25385 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_new(a, b, c);
25386 return nativeResponseValue;
25388 // void C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ _res);
25390 export function C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(_res: bigint): void {
25391 if(!isWasmInitialized) {
25392 throw new Error("initializeWasm() must be awaited first!");
25394 const nativeResponseValue = wasm.TS_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(_res);
25395 // debug statements here
25397 // struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_ok(struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ o);
25399 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_ok(o: bigint): bigint {
25400 if(!isWasmInitialized) {
25401 throw new Error("initializeWasm() must be awaited first!");
25403 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_ok(o);
25404 return nativeResponseValue;
25406 // struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_err(struct LDKSendError e);
25408 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_err(e: bigint): bigint {
25409 if(!isWasmInitialized) {
25410 throw new Error("initializeWasm() must be awaited first!");
25412 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_err(e);
25413 return nativeResponseValue;
25415 // bool CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_is_ok(const struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ *NONNULL_PTR o);
25417 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_is_ok(o: bigint): boolean {
25418 if(!isWasmInitialized) {
25419 throw new Error("initializeWasm() must be awaited first!");
25421 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_is_ok(o);
25422 return nativeResponseValue;
25424 // void CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ _res);
25426 export function CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(_res: bigint): void {
25427 if(!isWasmInitialized) {
25428 throw new Error("initializeWasm() must be awaited first!");
25430 const nativeResponseValue = wasm.TS_CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(_res);
25431 // debug statements here
25433 // struct LDKCResult_PeeledOnionNoneZ CResult_PeeledOnionNoneZ_ok(struct LDKPeeledOnion o);
25435 export function CResult_PeeledOnionNoneZ_ok(o: bigint): bigint {
25436 if(!isWasmInitialized) {
25437 throw new Error("initializeWasm() must be awaited first!");
25439 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_ok(o);
25440 return nativeResponseValue;
25442 // struct LDKCResult_PeeledOnionNoneZ CResult_PeeledOnionNoneZ_err(void);
25444 export function CResult_PeeledOnionNoneZ_err(): bigint {
25445 if(!isWasmInitialized) {
25446 throw new Error("initializeWasm() must be awaited first!");
25448 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_err();
25449 return nativeResponseValue;
25451 // bool CResult_PeeledOnionNoneZ_is_ok(const struct LDKCResult_PeeledOnionNoneZ *NONNULL_PTR o);
25453 export function CResult_PeeledOnionNoneZ_is_ok(o: bigint): boolean {
25454 if(!isWasmInitialized) {
25455 throw new Error("initializeWasm() must be awaited first!");
25457 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_is_ok(o);
25458 return nativeResponseValue;
25460 // void CResult_PeeledOnionNoneZ_free(struct LDKCResult_PeeledOnionNoneZ _res);
25462 export function CResult_PeeledOnionNoneZ_free(_res: bigint): void {
25463 if(!isWasmInitialized) {
25464 throw new Error("initializeWasm() must be awaited first!");
25466 const nativeResponseValue = wasm.TS_CResult_PeeledOnionNoneZ_free(_res);
25467 // debug statements here
25469 // struct LDKCResult_SendSuccessSendErrorZ CResult_SendSuccessSendErrorZ_ok(struct LDKSendSuccess o);
25471 export function CResult_SendSuccessSendErrorZ_ok(o: bigint): bigint {
25472 if(!isWasmInitialized) {
25473 throw new Error("initializeWasm() must be awaited first!");
25475 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_ok(o);
25476 return nativeResponseValue;
25478 // struct LDKCResult_SendSuccessSendErrorZ CResult_SendSuccessSendErrorZ_err(struct LDKSendError e);
25480 export function CResult_SendSuccessSendErrorZ_err(e: bigint): bigint {
25481 if(!isWasmInitialized) {
25482 throw new Error("initializeWasm() must be awaited first!");
25484 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_err(e);
25485 return nativeResponseValue;
25487 // bool CResult_SendSuccessSendErrorZ_is_ok(const struct LDKCResult_SendSuccessSendErrorZ *NONNULL_PTR o);
25489 export function CResult_SendSuccessSendErrorZ_is_ok(o: bigint): boolean {
25490 if(!isWasmInitialized) {
25491 throw new Error("initializeWasm() must be awaited first!");
25493 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_is_ok(o);
25494 return nativeResponseValue;
25496 // void CResult_SendSuccessSendErrorZ_free(struct LDKCResult_SendSuccessSendErrorZ _res);
25498 export function CResult_SendSuccessSendErrorZ_free(_res: bigint): void {
25499 if(!isWasmInitialized) {
25500 throw new Error("initializeWasm() must be awaited first!");
25502 const nativeResponseValue = wasm.TS_CResult_SendSuccessSendErrorZ_free(_res);
25503 // debug statements here
25505 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_ok(struct LDKBlindedPath o);
25507 export function CResult_BlindedPathNoneZ_ok(o: bigint): bigint {
25508 if(!isWasmInitialized) {
25509 throw new Error("initializeWasm() must be awaited first!");
25511 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_ok(o);
25512 return nativeResponseValue;
25514 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_err(void);
25516 export function CResult_BlindedPathNoneZ_err(): bigint {
25517 if(!isWasmInitialized) {
25518 throw new Error("initializeWasm() must be awaited first!");
25520 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_err();
25521 return nativeResponseValue;
25523 // bool CResult_BlindedPathNoneZ_is_ok(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR o);
25525 export function CResult_BlindedPathNoneZ_is_ok(o: bigint): boolean {
25526 if(!isWasmInitialized) {
25527 throw new Error("initializeWasm() must be awaited first!");
25529 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_is_ok(o);
25530 return nativeResponseValue;
25532 // void CResult_BlindedPathNoneZ_free(struct LDKCResult_BlindedPathNoneZ _res);
25534 export function CResult_BlindedPathNoneZ_free(_res: bigint): void {
25535 if(!isWasmInitialized) {
25536 throw new Error("initializeWasm() must be awaited first!");
25538 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_free(_res);
25539 // debug statements here
25541 // uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg);
25543 export function CResult_BlindedPathNoneZ_clone_ptr(arg: bigint): bigint {
25544 if(!isWasmInitialized) {
25545 throw new Error("initializeWasm() must be awaited first!");
25547 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone_ptr(arg);
25548 return nativeResponseValue;
25550 // struct LDKCResult_BlindedPathNoneZ CResult_BlindedPathNoneZ_clone(const struct LDKCResult_BlindedPathNoneZ *NONNULL_PTR orig);
25552 export function CResult_BlindedPathNoneZ_clone(orig: bigint): bigint {
25553 if(!isWasmInitialized) {
25554 throw new Error("initializeWasm() must be awaited first!");
25556 const nativeResponseValue = wasm.TS_CResult_BlindedPathNoneZ_clone(orig);
25557 return nativeResponseValue;
25559 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ o);
25561 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(o: bigint): bigint {
25562 if(!isWasmInitialized) {
25563 throw new Error("initializeWasm() must be awaited first!");
25565 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(o);
25566 return nativeResponseValue;
25568 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err(void);
25570 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err(): bigint {
25571 if(!isWasmInitialized) {
25572 throw new Error("initializeWasm() must be awaited first!");
25574 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err();
25575 return nativeResponseValue;
25577 // bool CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(const struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR o);
25579 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(o: bigint): boolean {
25580 if(!isWasmInitialized) {
25581 throw new Error("initializeWasm() must be awaited first!");
25583 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(o);
25584 return nativeResponseValue;
25586 // void CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ _res);
25588 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(_res: bigint): void {
25589 if(!isWasmInitialized) {
25590 throw new Error("initializeWasm() must be awaited first!");
25592 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(_res);
25593 // debug statements here
25595 // uint64_t CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR arg);
25597 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(arg: bigint): bigint {
25598 if(!isWasmInitialized) {
25599 throw new Error("initializeWasm() must be awaited first!");
25601 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(arg);
25602 return nativeResponseValue;
25604 // struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(const struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR orig);
25606 export function CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(orig: bigint): bigint {
25607 if(!isWasmInitialized) {
25608 throw new Error("initializeWasm() must be awaited first!");
25610 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(orig);
25611 return nativeResponseValue;
25613 // void CVec_ForwardNodeZ_free(struct LDKCVec_ForwardNodeZ _res);
25615 export function CVec_ForwardNodeZ_free(_res: number): void {
25616 if(!isWasmInitialized) {
25617 throw new Error("initializeWasm() must be awaited first!");
25619 const nativeResponseValue = wasm.TS_CVec_ForwardNodeZ_free(_res);
25620 // debug statements here
25622 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_ok(struct LDKBlindedPath o);
25624 export function CResult_BlindedPathDecodeErrorZ_ok(o: bigint): bigint {
25625 if(!isWasmInitialized) {
25626 throw new Error("initializeWasm() must be awaited first!");
25628 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_ok(o);
25629 return nativeResponseValue;
25631 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_err(struct LDKDecodeError e);
25633 export function CResult_BlindedPathDecodeErrorZ_err(e: bigint): bigint {
25634 if(!isWasmInitialized) {
25635 throw new Error("initializeWasm() must be awaited first!");
25637 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_err(e);
25638 return nativeResponseValue;
25640 // bool CResult_BlindedPathDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR o);
25642 export function CResult_BlindedPathDecodeErrorZ_is_ok(o: bigint): boolean {
25643 if(!isWasmInitialized) {
25644 throw new Error("initializeWasm() must be awaited first!");
25646 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_is_ok(o);
25647 return nativeResponseValue;
25649 // void CResult_BlindedPathDecodeErrorZ_free(struct LDKCResult_BlindedPathDecodeErrorZ _res);
25651 export function CResult_BlindedPathDecodeErrorZ_free(_res: bigint): void {
25652 if(!isWasmInitialized) {
25653 throw new Error("initializeWasm() must be awaited first!");
25655 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_free(_res);
25656 // debug statements here
25658 // uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg);
25660 export function CResult_BlindedPathDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25661 if(!isWasmInitialized) {
25662 throw new Error("initializeWasm() must be awaited first!");
25664 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(arg);
25665 return nativeResponseValue;
25667 // struct LDKCResult_BlindedPathDecodeErrorZ CResult_BlindedPathDecodeErrorZ_clone(const struct LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR orig);
25669 export function CResult_BlindedPathDecodeErrorZ_clone(orig: bigint): bigint {
25670 if(!isWasmInitialized) {
25671 throw new Error("initializeWasm() must be awaited first!");
25673 const nativeResponseValue = wasm.TS_CResult_BlindedPathDecodeErrorZ_clone(orig);
25674 return nativeResponseValue;
25676 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_ok(struct LDKBlindedHop o);
25678 export function CResult_BlindedHopDecodeErrorZ_ok(o: bigint): bigint {
25679 if(!isWasmInitialized) {
25680 throw new Error("initializeWasm() must be awaited first!");
25682 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_ok(o);
25683 return nativeResponseValue;
25685 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_err(struct LDKDecodeError e);
25687 export function CResult_BlindedHopDecodeErrorZ_err(e: bigint): bigint {
25688 if(!isWasmInitialized) {
25689 throw new Error("initializeWasm() must be awaited first!");
25691 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_err(e);
25692 return nativeResponseValue;
25694 // bool CResult_BlindedHopDecodeErrorZ_is_ok(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR o);
25696 export function CResult_BlindedHopDecodeErrorZ_is_ok(o: bigint): boolean {
25697 if(!isWasmInitialized) {
25698 throw new Error("initializeWasm() must be awaited first!");
25700 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_is_ok(o);
25701 return nativeResponseValue;
25703 // void CResult_BlindedHopDecodeErrorZ_free(struct LDKCResult_BlindedHopDecodeErrorZ _res);
25705 export function CResult_BlindedHopDecodeErrorZ_free(_res: bigint): void {
25706 if(!isWasmInitialized) {
25707 throw new Error("initializeWasm() must be awaited first!");
25709 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_free(_res);
25710 // debug statements here
25712 // uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg);
25714 export function CResult_BlindedHopDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25715 if(!isWasmInitialized) {
25716 throw new Error("initializeWasm() must be awaited first!");
25718 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(arg);
25719 return nativeResponseValue;
25721 // struct LDKCResult_BlindedHopDecodeErrorZ CResult_BlindedHopDecodeErrorZ_clone(const struct LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR orig);
25723 export function CResult_BlindedHopDecodeErrorZ_clone(orig: bigint): bigint {
25724 if(!isWasmInitialized) {
25725 throw new Error("initializeWasm() must be awaited first!");
25727 const nativeResponseValue = wasm.TS_CResult_BlindedHopDecodeErrorZ_clone(orig);
25728 return nativeResponseValue;
25730 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_ok(struct LDKInvoiceError o);
25732 export function CResult_InvoiceErrorDecodeErrorZ_ok(o: bigint): bigint {
25733 if(!isWasmInitialized) {
25734 throw new Error("initializeWasm() must be awaited first!");
25736 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_ok(o);
25737 return nativeResponseValue;
25739 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_err(struct LDKDecodeError e);
25741 export function CResult_InvoiceErrorDecodeErrorZ_err(e: bigint): bigint {
25742 if(!isWasmInitialized) {
25743 throw new Error("initializeWasm() must be awaited first!");
25745 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_err(e);
25746 return nativeResponseValue;
25748 // bool CResult_InvoiceErrorDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR o);
25750 export function CResult_InvoiceErrorDecodeErrorZ_is_ok(o: bigint): boolean {
25751 if(!isWasmInitialized) {
25752 throw new Error("initializeWasm() must be awaited first!");
25754 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_is_ok(o);
25755 return nativeResponseValue;
25757 // void CResult_InvoiceErrorDecodeErrorZ_free(struct LDKCResult_InvoiceErrorDecodeErrorZ _res);
25759 export function CResult_InvoiceErrorDecodeErrorZ_free(_res: bigint): void {
25760 if(!isWasmInitialized) {
25761 throw new Error("initializeWasm() must be awaited first!");
25763 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_free(_res);
25764 // debug statements here
25766 // uint64_t CResult_InvoiceErrorDecodeErrorZ_clone_ptr(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR arg);
25768 export function CResult_InvoiceErrorDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25769 if(!isWasmInitialized) {
25770 throw new Error("initializeWasm() must be awaited first!");
25772 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_clone_ptr(arg);
25773 return nativeResponseValue;
25775 // struct LDKCResult_InvoiceErrorDecodeErrorZ CResult_InvoiceErrorDecodeErrorZ_clone(const struct LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR orig);
25777 export function CResult_InvoiceErrorDecodeErrorZ_clone(orig: bigint): bigint {
25778 if(!isWasmInitialized) {
25779 throw new Error("initializeWasm() must be awaited first!");
25781 const nativeResponseValue = wasm.TS_CResult_InvoiceErrorDecodeErrorZ_clone(orig);
25782 return nativeResponseValue;
25784 // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ CResult_DelayedPaymentBasepointDecodeErrorZ_ok(struct LDKDelayedPaymentBasepoint o);
25786 export function CResult_DelayedPaymentBasepointDecodeErrorZ_ok(o: bigint): bigint {
25787 if(!isWasmInitialized) {
25788 throw new Error("initializeWasm() must be awaited first!");
25790 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_ok(o);
25791 return nativeResponseValue;
25793 // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ CResult_DelayedPaymentBasepointDecodeErrorZ_err(struct LDKDecodeError e);
25795 export function CResult_DelayedPaymentBasepointDecodeErrorZ_err(e: bigint): bigint {
25796 if(!isWasmInitialized) {
25797 throw new Error("initializeWasm() must be awaited first!");
25799 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_err(e);
25800 return nativeResponseValue;
25802 // bool CResult_DelayedPaymentBasepointDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR o);
25804 export function CResult_DelayedPaymentBasepointDecodeErrorZ_is_ok(o: bigint): boolean {
25805 if(!isWasmInitialized) {
25806 throw new Error("initializeWasm() must be awaited first!");
25808 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_is_ok(o);
25809 return nativeResponseValue;
25811 // void CResult_DelayedPaymentBasepointDecodeErrorZ_free(struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ _res);
25813 export function CResult_DelayedPaymentBasepointDecodeErrorZ_free(_res: bigint): void {
25814 if(!isWasmInitialized) {
25815 throw new Error("initializeWasm() must be awaited first!");
25817 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_free(_res);
25818 // debug statements here
25820 // uint64_t CResult_DelayedPaymentBasepointDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR arg);
25822 export function CResult_DelayedPaymentBasepointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25823 if(!isWasmInitialized) {
25824 throw new Error("initializeWasm() must be awaited first!");
25826 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_clone_ptr(arg);
25827 return nativeResponseValue;
25829 // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ CResult_DelayedPaymentBasepointDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR orig);
25831 export function CResult_DelayedPaymentBasepointDecodeErrorZ_clone(orig: bigint): bigint {
25832 if(!isWasmInitialized) {
25833 throw new Error("initializeWasm() must be awaited first!");
25835 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_clone(orig);
25836 return nativeResponseValue;
25838 // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ CResult_DelayedPaymentKeyDecodeErrorZ_ok(struct LDKDelayedPaymentKey o);
25840 export function CResult_DelayedPaymentKeyDecodeErrorZ_ok(o: bigint): bigint {
25841 if(!isWasmInitialized) {
25842 throw new Error("initializeWasm() must be awaited first!");
25844 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_ok(o);
25845 return nativeResponseValue;
25847 // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ CResult_DelayedPaymentKeyDecodeErrorZ_err(struct LDKDecodeError e);
25849 export function CResult_DelayedPaymentKeyDecodeErrorZ_err(e: bigint): bigint {
25850 if(!isWasmInitialized) {
25851 throw new Error("initializeWasm() must be awaited first!");
25853 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_err(e);
25854 return nativeResponseValue;
25856 // bool CResult_DelayedPaymentKeyDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR o);
25858 export function CResult_DelayedPaymentKeyDecodeErrorZ_is_ok(o: bigint): boolean {
25859 if(!isWasmInitialized) {
25860 throw new Error("initializeWasm() must be awaited first!");
25862 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_is_ok(o);
25863 return nativeResponseValue;
25865 // void CResult_DelayedPaymentKeyDecodeErrorZ_free(struct LDKCResult_DelayedPaymentKeyDecodeErrorZ _res);
25867 export function CResult_DelayedPaymentKeyDecodeErrorZ_free(_res: bigint): void {
25868 if(!isWasmInitialized) {
25869 throw new Error("initializeWasm() must be awaited first!");
25871 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_free(_res);
25872 // debug statements here
25874 // uint64_t CResult_DelayedPaymentKeyDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR arg);
25876 export function CResult_DelayedPaymentKeyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25877 if(!isWasmInitialized) {
25878 throw new Error("initializeWasm() must be awaited first!");
25880 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_clone_ptr(arg);
25881 return nativeResponseValue;
25883 // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ CResult_DelayedPaymentKeyDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR orig);
25885 export function CResult_DelayedPaymentKeyDecodeErrorZ_clone(orig: bigint): bigint {
25886 if(!isWasmInitialized) {
25887 throw new Error("initializeWasm() must be awaited first!");
25889 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_clone(orig);
25890 return nativeResponseValue;
25892 // struct LDKCResult_HtlcBasepointDecodeErrorZ CResult_HtlcBasepointDecodeErrorZ_ok(struct LDKHtlcBasepoint o);
25894 export function CResult_HtlcBasepointDecodeErrorZ_ok(o: bigint): bigint {
25895 if(!isWasmInitialized) {
25896 throw new Error("initializeWasm() must be awaited first!");
25898 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_ok(o);
25899 return nativeResponseValue;
25901 // struct LDKCResult_HtlcBasepointDecodeErrorZ CResult_HtlcBasepointDecodeErrorZ_err(struct LDKDecodeError e);
25903 export function CResult_HtlcBasepointDecodeErrorZ_err(e: bigint): bigint {
25904 if(!isWasmInitialized) {
25905 throw new Error("initializeWasm() must be awaited first!");
25907 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_err(e);
25908 return nativeResponseValue;
25910 // bool CResult_HtlcBasepointDecodeErrorZ_is_ok(const struct LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR o);
25912 export function CResult_HtlcBasepointDecodeErrorZ_is_ok(o: bigint): boolean {
25913 if(!isWasmInitialized) {
25914 throw new Error("initializeWasm() must be awaited first!");
25916 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_is_ok(o);
25917 return nativeResponseValue;
25919 // void CResult_HtlcBasepointDecodeErrorZ_free(struct LDKCResult_HtlcBasepointDecodeErrorZ _res);
25921 export function CResult_HtlcBasepointDecodeErrorZ_free(_res: bigint): void {
25922 if(!isWasmInitialized) {
25923 throw new Error("initializeWasm() must be awaited first!");
25925 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_free(_res);
25926 // debug statements here
25928 // uint64_t CResult_HtlcBasepointDecodeErrorZ_clone_ptr(LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR arg);
25930 export function CResult_HtlcBasepointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25931 if(!isWasmInitialized) {
25932 throw new Error("initializeWasm() must be awaited first!");
25934 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_clone_ptr(arg);
25935 return nativeResponseValue;
25937 // struct LDKCResult_HtlcBasepointDecodeErrorZ CResult_HtlcBasepointDecodeErrorZ_clone(const struct LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR orig);
25939 export function CResult_HtlcBasepointDecodeErrorZ_clone(orig: bigint): bigint {
25940 if(!isWasmInitialized) {
25941 throw new Error("initializeWasm() must be awaited first!");
25943 const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_clone(orig);
25944 return nativeResponseValue;
25946 // struct LDKCResult_HtlcKeyDecodeErrorZ CResult_HtlcKeyDecodeErrorZ_ok(struct LDKHtlcKey o);
25948 export function CResult_HtlcKeyDecodeErrorZ_ok(o: bigint): bigint {
25949 if(!isWasmInitialized) {
25950 throw new Error("initializeWasm() must be awaited first!");
25952 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_ok(o);
25953 return nativeResponseValue;
25955 // struct LDKCResult_HtlcKeyDecodeErrorZ CResult_HtlcKeyDecodeErrorZ_err(struct LDKDecodeError e);
25957 export function CResult_HtlcKeyDecodeErrorZ_err(e: bigint): bigint {
25958 if(!isWasmInitialized) {
25959 throw new Error("initializeWasm() must be awaited first!");
25961 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_err(e);
25962 return nativeResponseValue;
25964 // bool CResult_HtlcKeyDecodeErrorZ_is_ok(const struct LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR o);
25966 export function CResult_HtlcKeyDecodeErrorZ_is_ok(o: bigint): boolean {
25967 if(!isWasmInitialized) {
25968 throw new Error("initializeWasm() must be awaited first!");
25970 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_is_ok(o);
25971 return nativeResponseValue;
25973 // void CResult_HtlcKeyDecodeErrorZ_free(struct LDKCResult_HtlcKeyDecodeErrorZ _res);
25975 export function CResult_HtlcKeyDecodeErrorZ_free(_res: bigint): void {
25976 if(!isWasmInitialized) {
25977 throw new Error("initializeWasm() must be awaited first!");
25979 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_free(_res);
25980 // debug statements here
25982 // uint64_t CResult_HtlcKeyDecodeErrorZ_clone_ptr(LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR arg);
25984 export function CResult_HtlcKeyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
25985 if(!isWasmInitialized) {
25986 throw new Error("initializeWasm() must be awaited first!");
25988 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_clone_ptr(arg);
25989 return nativeResponseValue;
25991 // struct LDKCResult_HtlcKeyDecodeErrorZ CResult_HtlcKeyDecodeErrorZ_clone(const struct LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR orig);
25993 export function CResult_HtlcKeyDecodeErrorZ_clone(orig: bigint): bigint {
25994 if(!isWasmInitialized) {
25995 throw new Error("initializeWasm() must be awaited first!");
25997 const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_clone(orig);
25998 return nativeResponseValue;
26000 // struct LDKCResult_RevocationBasepointDecodeErrorZ CResult_RevocationBasepointDecodeErrorZ_ok(struct LDKRevocationBasepoint o);
26002 export function CResult_RevocationBasepointDecodeErrorZ_ok(o: bigint): bigint {
26003 if(!isWasmInitialized) {
26004 throw new Error("initializeWasm() must be awaited first!");
26006 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_ok(o);
26007 return nativeResponseValue;
26009 // struct LDKCResult_RevocationBasepointDecodeErrorZ CResult_RevocationBasepointDecodeErrorZ_err(struct LDKDecodeError e);
26011 export function CResult_RevocationBasepointDecodeErrorZ_err(e: bigint): bigint {
26012 if(!isWasmInitialized) {
26013 throw new Error("initializeWasm() must be awaited first!");
26015 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_err(e);
26016 return nativeResponseValue;
26018 // bool CResult_RevocationBasepointDecodeErrorZ_is_ok(const struct LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR o);
26020 export function CResult_RevocationBasepointDecodeErrorZ_is_ok(o: bigint): boolean {
26021 if(!isWasmInitialized) {
26022 throw new Error("initializeWasm() must be awaited first!");
26024 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_is_ok(o);
26025 return nativeResponseValue;
26027 // void CResult_RevocationBasepointDecodeErrorZ_free(struct LDKCResult_RevocationBasepointDecodeErrorZ _res);
26029 export function CResult_RevocationBasepointDecodeErrorZ_free(_res: bigint): void {
26030 if(!isWasmInitialized) {
26031 throw new Error("initializeWasm() must be awaited first!");
26033 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_free(_res);
26034 // debug statements here
26036 // uint64_t CResult_RevocationBasepointDecodeErrorZ_clone_ptr(LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR arg);
26038 export function CResult_RevocationBasepointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
26039 if(!isWasmInitialized) {
26040 throw new Error("initializeWasm() must be awaited first!");
26042 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_clone_ptr(arg);
26043 return nativeResponseValue;
26045 // struct LDKCResult_RevocationBasepointDecodeErrorZ CResult_RevocationBasepointDecodeErrorZ_clone(const struct LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR orig);
26047 export function CResult_RevocationBasepointDecodeErrorZ_clone(orig: bigint): bigint {
26048 if(!isWasmInitialized) {
26049 throw new Error("initializeWasm() must be awaited first!");
26051 const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_clone(orig);
26052 return nativeResponseValue;
26054 // struct LDKCResult_RevocationKeyDecodeErrorZ CResult_RevocationKeyDecodeErrorZ_ok(struct LDKRevocationKey o);
26056 export function CResult_RevocationKeyDecodeErrorZ_ok(o: bigint): bigint {
26057 if(!isWasmInitialized) {
26058 throw new Error("initializeWasm() must be awaited first!");
26060 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_ok(o);
26061 return nativeResponseValue;
26063 // struct LDKCResult_RevocationKeyDecodeErrorZ CResult_RevocationKeyDecodeErrorZ_err(struct LDKDecodeError e);
26065 export function CResult_RevocationKeyDecodeErrorZ_err(e: bigint): bigint {
26066 if(!isWasmInitialized) {
26067 throw new Error("initializeWasm() must be awaited first!");
26069 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_err(e);
26070 return nativeResponseValue;
26072 // bool CResult_RevocationKeyDecodeErrorZ_is_ok(const struct LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR o);
26074 export function CResult_RevocationKeyDecodeErrorZ_is_ok(o: bigint): boolean {
26075 if(!isWasmInitialized) {
26076 throw new Error("initializeWasm() must be awaited first!");
26078 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_is_ok(o);
26079 return nativeResponseValue;
26081 // void CResult_RevocationKeyDecodeErrorZ_free(struct LDKCResult_RevocationKeyDecodeErrorZ _res);
26083 export function CResult_RevocationKeyDecodeErrorZ_free(_res: bigint): void {
26084 if(!isWasmInitialized) {
26085 throw new Error("initializeWasm() must be awaited first!");
26087 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_free(_res);
26088 // debug statements here
26090 // uint64_t CResult_RevocationKeyDecodeErrorZ_clone_ptr(LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR arg);
26092 export function CResult_RevocationKeyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
26093 if(!isWasmInitialized) {
26094 throw new Error("initializeWasm() must be awaited first!");
26096 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_clone_ptr(arg);
26097 return nativeResponseValue;
26099 // struct LDKCResult_RevocationKeyDecodeErrorZ CResult_RevocationKeyDecodeErrorZ_clone(const struct LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR orig);
26101 export function CResult_RevocationKeyDecodeErrorZ_clone(orig: bigint): bigint {
26102 if(!isWasmInitialized) {
26103 throw new Error("initializeWasm() must be awaited first!");
26105 const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_clone(orig);
26106 return nativeResponseValue;
26108 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
26110 export function COption_FilterZ_some(o: bigint): bigint {
26111 if(!isWasmInitialized) {
26112 throw new Error("initializeWasm() must be awaited first!");
26114 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
26115 return nativeResponseValue;
26117 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
26119 export function COption_FilterZ_none(): bigint {
26120 if(!isWasmInitialized) {
26121 throw new Error("initializeWasm() must be awaited first!");
26123 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
26124 return nativeResponseValue;
26126 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
26128 export function COption_FilterZ_free(_res: bigint): void {
26129 if(!isWasmInitialized) {
26130 throw new Error("initializeWasm() must be awaited first!");
26132 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
26133 // debug statements here
26135 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
26137 export function CResult_LockedChannelMonitorNoneZ_ok(o: bigint): bigint {
26138 if(!isWasmInitialized) {
26139 throw new Error("initializeWasm() must be awaited first!");
26141 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
26142 return nativeResponseValue;
26144 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
26146 export function CResult_LockedChannelMonitorNoneZ_err(): bigint {
26147 if(!isWasmInitialized) {
26148 throw new Error("initializeWasm() must be awaited first!");
26150 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
26151 return nativeResponseValue;
26153 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
26155 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: bigint): boolean {
26156 if(!isWasmInitialized) {
26157 throw new Error("initializeWasm() must be awaited first!");
26159 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
26160 return nativeResponseValue;
26162 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
26164 export function CResult_LockedChannelMonitorNoneZ_free(_res: bigint): void {
26165 if(!isWasmInitialized) {
26166 throw new Error("initializeWasm() must be awaited first!");
26168 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
26169 // debug statements here
26171 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
26173 export function CVec_OutPointZ_free(_res: number): void {
26174 if(!isWasmInitialized) {
26175 throw new Error("initializeWasm() must be awaited first!");
26177 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
26178 // debug statements here
26180 // void CVec_MonitorUpdateIdZ_free(struct LDKCVec_MonitorUpdateIdZ _res);
26182 export function CVec_MonitorUpdateIdZ_free(_res: number): void {
26183 if(!isWasmInitialized) {
26184 throw new Error("initializeWasm() must be awaited first!");
26186 const nativeResponseValue = wasm.TS_CVec_MonitorUpdateIdZ_free(_res);
26187 // debug statements here
26189 // uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg);
26191 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg: bigint): bigint {
26192 if(!isWasmInitialized) {
26193 throw new Error("initializeWasm() must be awaited first!");
26195 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg);
26196 return nativeResponseValue;
26198 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR orig);
26200 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig: bigint): bigint {
26201 if(!isWasmInitialized) {
26202 throw new Error("initializeWasm() must be awaited first!");
26204 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig);
26205 return nativeResponseValue;
26207 // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorUpdateIdZ b);
26209 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a: bigint, b: number): bigint {
26210 if(!isWasmInitialized) {
26211 throw new Error("initializeWasm() must be awaited first!");
26213 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a, b);
26214 return nativeResponseValue;
26216 // void C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res);
26218 export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res: bigint): void {
26219 if(!isWasmInitialized) {
26220 throw new Error("initializeWasm() must be awaited first!");
26222 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res);
26223 // debug statements here
26225 // void CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res);
26227 export function CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res: number): void {
26228 if(!isWasmInitialized) {
26229 throw new Error("initializeWasm() must be awaited first!");
26231 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res);
26232 // debug statements here
26234 // void APIError_free(struct LDKAPIError this_ptr);
26236 export function APIError_free(this_ptr: bigint): void {
26237 if(!isWasmInitialized) {
26238 throw new Error("initializeWasm() must be awaited first!");
26240 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
26241 // debug statements here
26243 // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
26245 export function APIError_clone_ptr(arg: bigint): bigint {
26246 if(!isWasmInitialized) {
26247 throw new Error("initializeWasm() must be awaited first!");
26249 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
26250 return nativeResponseValue;
26252 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
26254 export function APIError_clone(orig: bigint): bigint {
26255 if(!isWasmInitialized) {
26256 throw new Error("initializeWasm() must be awaited first!");
26258 const nativeResponseValue = wasm.TS_APIError_clone(orig);
26259 return nativeResponseValue;
26261 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
26263 export function APIError_apimisuse_error(err: number): bigint {
26264 if(!isWasmInitialized) {
26265 throw new Error("initializeWasm() must be awaited first!");
26267 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
26268 return nativeResponseValue;
26270 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
26272 export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
26273 if(!isWasmInitialized) {
26274 throw new Error("initializeWasm() must be awaited first!");
26276 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
26277 return nativeResponseValue;
26279 // struct LDKAPIError APIError_invalid_route(struct LDKStr err);
26281 export function APIError_invalid_route(err: number): bigint {
26282 if(!isWasmInitialized) {
26283 throw new Error("initializeWasm() must be awaited first!");
26285 const nativeResponseValue = wasm.TS_APIError_invalid_route(err);
26286 return nativeResponseValue;
26288 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
26290 export function APIError_channel_unavailable(err: number): bigint {
26291 if(!isWasmInitialized) {
26292 throw new Error("initializeWasm() must be awaited first!");
26294 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
26295 return nativeResponseValue;
26297 // struct LDKAPIError APIError_monitor_update_in_progress(void);
26299 export function APIError_monitor_update_in_progress(): bigint {
26300 if(!isWasmInitialized) {
26301 throw new Error("initializeWasm() must be awaited first!");
26303 const nativeResponseValue = wasm.TS_APIError_monitor_update_in_progress();
26304 return nativeResponseValue;
26306 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
26308 export function APIError_incompatible_shutdown_script(script: bigint): bigint {
26309 if(!isWasmInitialized) {
26310 throw new Error("initializeWasm() must be awaited first!");
26312 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
26313 return nativeResponseValue;
26315 // bool APIError_eq(const struct LDKAPIError *NONNULL_PTR a, const struct LDKAPIError *NONNULL_PTR b);
26317 export function APIError_eq(a: bigint, b: bigint): boolean {
26318 if(!isWasmInitialized) {
26319 throw new Error("initializeWasm() must be awaited first!");
26321 const nativeResponseValue = wasm.TS_APIError_eq(a, b);
26322 return nativeResponseValue;
26324 // struct LDKCVec_u8Z APIError_write(const struct LDKAPIError *NONNULL_PTR obj);
26326 export function APIError_write(obj: bigint): number {
26327 if(!isWasmInitialized) {
26328 throw new Error("initializeWasm() must be awaited first!");
26330 const nativeResponseValue = wasm.TS_APIError_write(obj);
26331 return nativeResponseValue;
26333 // struct LDKCResult_COption_APIErrorZDecodeErrorZ APIError_read(struct LDKu8slice ser);
26335 export function APIError_read(ser: number): bigint {
26336 if(!isWasmInitialized) {
26337 throw new Error("initializeWasm() must be awaited first!");
26339 const nativeResponseValue = wasm.TS_APIError_read(ser);
26340 return nativeResponseValue;
26342 // void BigSize_free(struct LDKBigSize this_obj);
26344 export function BigSize_free(this_obj: bigint): void {
26345 if(!isWasmInitialized) {
26346 throw new Error("initializeWasm() must be awaited first!");
26348 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
26349 // debug statements here
26351 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
26353 export function BigSize_get_a(this_ptr: bigint): bigint {
26354 if(!isWasmInitialized) {
26355 throw new Error("initializeWasm() must be awaited first!");
26357 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
26358 return nativeResponseValue;
26360 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
26362 export function BigSize_set_a(this_ptr: bigint, val: bigint): void {
26363 if(!isWasmInitialized) {
26364 throw new Error("initializeWasm() must be awaited first!");
26366 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
26367 // debug statements here
26369 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
26371 export function BigSize_new(a_arg: bigint): bigint {
26372 if(!isWasmInitialized) {
26373 throw new Error("initializeWasm() must be awaited first!");
26375 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
26376 return nativeResponseValue;
26378 // uint64_t BigSize_clone_ptr(LDKBigSize *NONNULL_PTR arg);
26380 export function BigSize_clone_ptr(arg: bigint): bigint {
26381 if(!isWasmInitialized) {
26382 throw new Error("initializeWasm() must be awaited first!");
26384 const nativeResponseValue = wasm.TS_BigSize_clone_ptr(arg);
26385 return nativeResponseValue;
26387 // struct LDKBigSize BigSize_clone(const struct LDKBigSize *NONNULL_PTR orig);
26389 export function BigSize_clone(orig: bigint): bigint {
26390 if(!isWasmInitialized) {
26391 throw new Error("initializeWasm() must be awaited first!");
26393 const nativeResponseValue = wasm.TS_BigSize_clone(orig);
26394 return nativeResponseValue;
26396 // uint64_t BigSize_hash(const struct LDKBigSize *NONNULL_PTR o);
26398 export function BigSize_hash(o: bigint): bigint {
26399 if(!isWasmInitialized) {
26400 throw new Error("initializeWasm() must be awaited first!");
26402 const nativeResponseValue = wasm.TS_BigSize_hash(o);
26403 return nativeResponseValue;
26405 // bool BigSize_eq(const struct LDKBigSize *NONNULL_PTR a, const struct LDKBigSize *NONNULL_PTR b);
26407 export function BigSize_eq(a: bigint, b: bigint): boolean {
26408 if(!isWasmInitialized) {
26409 throw new Error("initializeWasm() must be awaited first!");
26411 const nativeResponseValue = wasm.TS_BigSize_eq(a, b);
26412 return nativeResponseValue;
26414 // struct LDKCVec_u8Z BigSize_write(const struct LDKBigSize *NONNULL_PTR obj);
26416 export function BigSize_write(obj: bigint): number {
26417 if(!isWasmInitialized) {
26418 throw new Error("initializeWasm() must be awaited first!");
26420 const nativeResponseValue = wasm.TS_BigSize_write(obj);
26421 return nativeResponseValue;
26423 // struct LDKCResult_BigSizeDecodeErrorZ BigSize_read(struct LDKu8slice ser);
26425 export function BigSize_read(ser: number): bigint {
26426 if(!isWasmInitialized) {
26427 throw new Error("initializeWasm() must be awaited first!");
26429 const nativeResponseValue = wasm.TS_BigSize_read(ser);
26430 return nativeResponseValue;
26432 // void Hostname_free(struct LDKHostname this_obj);
26434 export function Hostname_free(this_obj: bigint): void {
26435 if(!isWasmInitialized) {
26436 throw new Error("initializeWasm() must be awaited first!");
26438 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
26439 // debug statements here
26441 // uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
26443 export function Hostname_clone_ptr(arg: bigint): bigint {
26444 if(!isWasmInitialized) {
26445 throw new Error("initializeWasm() must be awaited first!");
26447 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
26448 return nativeResponseValue;
26450 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
26452 export function Hostname_clone(orig: bigint): bigint {
26453 if(!isWasmInitialized) {
26454 throw new Error("initializeWasm() must be awaited first!");
26456 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
26457 return nativeResponseValue;
26459 // uint64_t Hostname_hash(const struct LDKHostname *NONNULL_PTR o);
26461 export function Hostname_hash(o: bigint): bigint {
26462 if(!isWasmInitialized) {
26463 throw new Error("initializeWasm() must be awaited first!");
26465 const nativeResponseValue = wasm.TS_Hostname_hash(o);
26466 return nativeResponseValue;
26468 // bool Hostname_eq(const struct LDKHostname *NONNULL_PTR a, const struct LDKHostname *NONNULL_PTR b);
26470 export function Hostname_eq(a: bigint, b: bigint): boolean {
26471 if(!isWasmInitialized) {
26472 throw new Error("initializeWasm() must be awaited first!");
26474 const nativeResponseValue = wasm.TS_Hostname_eq(a, b);
26475 return nativeResponseValue;
26477 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
26479 export function Hostname_len(this_arg: bigint): number {
26480 if(!isWasmInitialized) {
26481 throw new Error("initializeWasm() must be awaited first!");
26483 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
26484 return nativeResponseValue;
26486 // struct LDKCVec_u8Z Hostname_write(const struct LDKHostname *NONNULL_PTR obj);
26488 export function Hostname_write(obj: bigint): number {
26489 if(!isWasmInitialized) {
26490 throw new Error("initializeWasm() must be awaited first!");
26492 const nativeResponseValue = wasm.TS_Hostname_write(obj);
26493 return nativeResponseValue;
26495 // struct LDKCResult_HostnameDecodeErrorZ Hostname_read(struct LDKu8slice ser);
26497 export function Hostname_read(ser: number): bigint {
26498 if(!isWasmInitialized) {
26499 throw new Error("initializeWasm() must be awaited first!");
26501 const nativeResponseValue = wasm.TS_Hostname_read(ser);
26502 return nativeResponseValue;
26504 // void TransactionU16LenLimited_free(struct LDKTransactionU16LenLimited this_obj);
26506 export function TransactionU16LenLimited_free(this_obj: bigint): void {
26507 if(!isWasmInitialized) {
26508 throw new Error("initializeWasm() must be awaited first!");
26510 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_free(this_obj);
26511 // debug statements here
26513 // uint64_t TransactionU16LenLimited_clone_ptr(LDKTransactionU16LenLimited *NONNULL_PTR arg);
26515 export function TransactionU16LenLimited_clone_ptr(arg: bigint): bigint {
26516 if(!isWasmInitialized) {
26517 throw new Error("initializeWasm() must be awaited first!");
26519 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone_ptr(arg);
26520 return nativeResponseValue;
26522 // struct LDKTransactionU16LenLimited TransactionU16LenLimited_clone(const struct LDKTransactionU16LenLimited *NONNULL_PTR orig);
26524 export function TransactionU16LenLimited_clone(orig: bigint): bigint {
26525 if(!isWasmInitialized) {
26526 throw new Error("initializeWasm() must be awaited first!");
26528 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone(orig);
26529 return nativeResponseValue;
26531 // uint64_t TransactionU16LenLimited_hash(const struct LDKTransactionU16LenLimited *NONNULL_PTR o);
26533 export function TransactionU16LenLimited_hash(o: bigint): bigint {
26534 if(!isWasmInitialized) {
26535 throw new Error("initializeWasm() must be awaited first!");
26537 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_hash(o);
26538 return nativeResponseValue;
26540 // bool TransactionU16LenLimited_eq(const struct LDKTransactionU16LenLimited *NONNULL_PTR a, const struct LDKTransactionU16LenLimited *NONNULL_PTR b);
26542 export function TransactionU16LenLimited_eq(a: bigint, b: bigint): boolean {
26543 if(!isWasmInitialized) {
26544 throw new Error("initializeWasm() must be awaited first!");
26546 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_eq(a, b);
26547 return nativeResponseValue;
26549 // MUST_USE_RES struct LDKCResult_TransactionU16LenLimitedNoneZ TransactionU16LenLimited_new(struct LDKTransaction transaction);
26551 export function TransactionU16LenLimited_new(transaction: number): bigint {
26552 if(!isWasmInitialized) {
26553 throw new Error("initializeWasm() must be awaited first!");
26555 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_new(transaction);
26556 return nativeResponseValue;
26558 // MUST_USE_RES struct LDKTransaction TransactionU16LenLimited_into_transaction(struct LDKTransactionU16LenLimited this_arg);
26560 export function TransactionU16LenLimited_into_transaction(this_arg: bigint): number {
26561 if(!isWasmInitialized) {
26562 throw new Error("initializeWasm() must be awaited first!");
26564 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_into_transaction(this_arg);
26565 return nativeResponseValue;
26567 // struct LDKCVec_u8Z TransactionU16LenLimited_write(const struct LDKTransactionU16LenLimited *NONNULL_PTR obj);
26569 export function TransactionU16LenLimited_write(obj: bigint): number {
26570 if(!isWasmInitialized) {
26571 throw new Error("initializeWasm() must be awaited first!");
26573 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_write(obj);
26574 return nativeResponseValue;
26576 // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ TransactionU16LenLimited_read(struct LDKu8slice ser);
26578 export function TransactionU16LenLimited_read(ser: number): bigint {
26579 if(!isWasmInitialized) {
26580 throw new Error("initializeWasm() must be awaited first!");
26582 const nativeResponseValue = wasm.TS_TransactionU16LenLimited_read(ser);
26583 return nativeResponseValue;
26585 // struct LDKCResult_StrSecp256k1ErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
26587 export function sign(msg: number, sk: number): bigint {
26588 if(!isWasmInitialized) {
26589 throw new Error("initializeWasm() must be awaited first!");
26591 const nativeResponseValue = wasm.TS_sign(msg, sk);
26592 return nativeResponseValue;
26594 // struct LDKCResult_PublicKeySecp256k1ErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
26596 export function recover_pk(msg: number, sig: number): bigint {
26597 if(!isWasmInitialized) {
26598 throw new Error("initializeWasm() must be awaited first!");
26600 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
26601 return nativeResponseValue;
26603 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
26605 export function verify(msg: number, sig: number, pk: number): boolean {
26606 if(!isWasmInitialized) {
26607 throw new Error("initializeWasm() must be awaited first!");
26609 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
26610 return nativeResponseValue;
26612 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z data_without_signature);
26614 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
26615 if(!isWasmInitialized) {
26616 throw new Error("initializeWasm() must be awaited first!");
26618 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
26619 return nativeResponseValue;
26621 // void KVStore_free(struct LDKKVStore this_ptr);
26623 export function KVStore_free(this_ptr: bigint): void {
26624 if(!isWasmInitialized) {
26625 throw new Error("initializeWasm() must be awaited first!");
26627 const nativeResponseValue = wasm.TS_KVStore_free(this_ptr);
26628 // debug statements here
26630 // void Persister_free(struct LDKPersister this_ptr);
26632 export function Persister_free(this_ptr: bigint): void {
26633 if(!isWasmInitialized) {
26634 throw new Error("initializeWasm() must be awaited first!");
26636 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
26637 // debug statements here
26639 // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ read_channel_monitors(struct LDKKVStore kv_store, struct LDKEntropySource entropy_source, struct LDKSignerProvider signer_provider);
26641 export function read_channel_monitors(kv_store: bigint, entropy_source: bigint, signer_provider: bigint): bigint {
26642 if(!isWasmInitialized) {
26643 throw new Error("initializeWasm() must be awaited first!");
26645 const nativeResponseValue = wasm.TS_read_channel_monitors(kv_store, entropy_source, signer_provider);
26646 return nativeResponseValue;
26648 // void MonitorUpdatingPersister_free(struct LDKMonitorUpdatingPersister this_obj);
26650 export function MonitorUpdatingPersister_free(this_obj: bigint): void {
26651 if(!isWasmInitialized) {
26652 throw new Error("initializeWasm() must be awaited first!");
26654 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_free(this_obj);
26655 // debug statements here
26657 // 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);
26659 export function MonitorUpdatingPersister_new(kv_store: bigint, logger: bigint, maximum_pending_updates: bigint, entropy_source: bigint, signer_provider: bigint): bigint {
26660 if(!isWasmInitialized) {
26661 throw new Error("initializeWasm() must be awaited first!");
26663 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_new(kv_store, logger, maximum_pending_updates, entropy_source, signer_provider);
26664 return nativeResponseValue;
26666 // 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);
26668 export function MonitorUpdatingPersister_read_all_channel_monitors_with_updates(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint): bigint {
26669 if(!isWasmInitialized) {
26670 throw new Error("initializeWasm() must be awaited first!");
26672 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_read_all_channel_monitors_with_updates(this_arg, broadcaster, fee_estimator);
26673 return nativeResponseValue;
26675 // 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);
26677 export function MonitorUpdatingPersister_read_channel_monitor_with_updates(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, monitor_key: number): bigint {
26678 if(!isWasmInitialized) {
26679 throw new Error("initializeWasm() must be awaited first!");
26681 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_read_channel_monitor_with_updates(this_arg, broadcaster, fee_estimator, monitor_key);
26682 return nativeResponseValue;
26684 // MUST_USE_RES struct LDKCResult_NoneIOErrorZ MonitorUpdatingPersister_cleanup_stale_updates(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg, bool lazy);
26686 export function MonitorUpdatingPersister_cleanup_stale_updates(this_arg: bigint, lazy: boolean): bigint {
26687 if(!isWasmInitialized) {
26688 throw new Error("initializeWasm() must be awaited first!");
26690 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_cleanup_stale_updates(this_arg, lazy);
26691 return nativeResponseValue;
26693 // struct LDKPersist MonitorUpdatingPersister_as_Persist(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg);
26695 export function MonitorUpdatingPersister_as_Persist(this_arg: bigint): bigint {
26696 if(!isWasmInitialized) {
26697 throw new Error("initializeWasm() must be awaited first!");
26699 const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_as_Persist(this_arg);
26700 return nativeResponseValue;
26702 // void UntrustedString_free(struct LDKUntrustedString this_obj);
26704 export function UntrustedString_free(this_obj: bigint): void {
26705 if(!isWasmInitialized) {
26706 throw new Error("initializeWasm() must be awaited first!");
26708 const nativeResponseValue = wasm.TS_UntrustedString_free(this_obj);
26709 // debug statements here
26711 // struct LDKStr UntrustedString_get_a(const struct LDKUntrustedString *NONNULL_PTR this_ptr);
26713 export function UntrustedString_get_a(this_ptr: bigint): number {
26714 if(!isWasmInitialized) {
26715 throw new Error("initializeWasm() must be awaited first!");
26717 const nativeResponseValue = wasm.TS_UntrustedString_get_a(this_ptr);
26718 return nativeResponseValue;
26720 // void UntrustedString_set_a(struct LDKUntrustedString *NONNULL_PTR this_ptr, struct LDKStr val);
26722 export function UntrustedString_set_a(this_ptr: bigint, val: number): void {
26723 if(!isWasmInitialized) {
26724 throw new Error("initializeWasm() must be awaited first!");
26726 const nativeResponseValue = wasm.TS_UntrustedString_set_a(this_ptr, val);
26727 // debug statements here
26729 // MUST_USE_RES struct LDKUntrustedString UntrustedString_new(struct LDKStr a_arg);
26731 export function UntrustedString_new(a_arg: number): bigint {
26732 if(!isWasmInitialized) {
26733 throw new Error("initializeWasm() must be awaited first!");
26735 const nativeResponseValue = wasm.TS_UntrustedString_new(a_arg);
26736 return nativeResponseValue;
26738 // uint64_t UntrustedString_clone_ptr(LDKUntrustedString *NONNULL_PTR arg);
26740 export function UntrustedString_clone_ptr(arg: bigint): bigint {
26741 if(!isWasmInitialized) {
26742 throw new Error("initializeWasm() must be awaited first!");
26744 const nativeResponseValue = wasm.TS_UntrustedString_clone_ptr(arg);
26745 return nativeResponseValue;
26747 // struct LDKUntrustedString UntrustedString_clone(const struct LDKUntrustedString *NONNULL_PTR orig);
26749 export function UntrustedString_clone(orig: bigint): bigint {
26750 if(!isWasmInitialized) {
26751 throw new Error("initializeWasm() must be awaited first!");
26753 const nativeResponseValue = wasm.TS_UntrustedString_clone(orig);
26754 return nativeResponseValue;
26756 // bool UntrustedString_eq(const struct LDKUntrustedString *NONNULL_PTR a, const struct LDKUntrustedString *NONNULL_PTR b);
26758 export function UntrustedString_eq(a: bigint, b: bigint): boolean {
26759 if(!isWasmInitialized) {
26760 throw new Error("initializeWasm() must be awaited first!");
26762 const nativeResponseValue = wasm.TS_UntrustedString_eq(a, b);
26763 return nativeResponseValue;
26765 // uint64_t UntrustedString_hash(const struct LDKUntrustedString *NONNULL_PTR o);
26767 export function UntrustedString_hash(o: bigint): bigint {
26768 if(!isWasmInitialized) {
26769 throw new Error("initializeWasm() must be awaited first!");
26771 const nativeResponseValue = wasm.TS_UntrustedString_hash(o);
26772 return nativeResponseValue;
26774 // struct LDKCVec_u8Z UntrustedString_write(const struct LDKUntrustedString *NONNULL_PTR obj);
26776 export function UntrustedString_write(obj: bigint): number {
26777 if(!isWasmInitialized) {
26778 throw new Error("initializeWasm() must be awaited first!");
26780 const nativeResponseValue = wasm.TS_UntrustedString_write(obj);
26781 return nativeResponseValue;
26783 // struct LDKCResult_UntrustedStringDecodeErrorZ UntrustedString_read(struct LDKu8slice ser);
26785 export function UntrustedString_read(ser: number): bigint {
26786 if(!isWasmInitialized) {
26787 throw new Error("initializeWasm() must be awaited first!");
26789 const nativeResponseValue = wasm.TS_UntrustedString_read(ser);
26790 return nativeResponseValue;
26792 // void PrintableString_free(struct LDKPrintableString this_obj);
26794 export function PrintableString_free(this_obj: bigint): void {
26795 if(!isWasmInitialized) {
26796 throw new Error("initializeWasm() must be awaited first!");
26798 const nativeResponseValue = wasm.TS_PrintableString_free(this_obj);
26799 // debug statements here
26801 // struct LDKStr PrintableString_get_a(const struct LDKPrintableString *NONNULL_PTR this_ptr);
26803 export function PrintableString_get_a(this_ptr: bigint): number {
26804 if(!isWasmInitialized) {
26805 throw new Error("initializeWasm() must be awaited first!");
26807 const nativeResponseValue = wasm.TS_PrintableString_get_a(this_ptr);
26808 return nativeResponseValue;
26810 // void PrintableString_set_a(struct LDKPrintableString *NONNULL_PTR this_ptr, struct LDKStr val);
26812 export function PrintableString_set_a(this_ptr: bigint, val: number): void {
26813 if(!isWasmInitialized) {
26814 throw new Error("initializeWasm() must be awaited first!");
26816 const nativeResponseValue = wasm.TS_PrintableString_set_a(this_ptr, val);
26817 // debug statements here
26819 // MUST_USE_RES struct LDKPrintableString PrintableString_new(struct LDKStr a_arg);
26821 export function PrintableString_new(a_arg: number): bigint {
26822 if(!isWasmInitialized) {
26823 throw new Error("initializeWasm() must be awaited first!");
26825 const nativeResponseValue = wasm.TS_PrintableString_new(a_arg);
26826 return nativeResponseValue;
26828 // void FutureCallback_free(struct LDKFutureCallback this_ptr);
26830 export function FutureCallback_free(this_ptr: bigint): void {
26831 if(!isWasmInitialized) {
26832 throw new Error("initializeWasm() must be awaited first!");
26834 const nativeResponseValue = wasm.TS_FutureCallback_free(this_ptr);
26835 // debug statements here
26837 // void Future_free(struct LDKFuture this_obj);
26839 export function Future_free(this_obj: bigint): void {
26840 if(!isWasmInitialized) {
26841 throw new Error("initializeWasm() must be awaited first!");
26843 const nativeResponseValue = wasm.TS_Future_free(this_obj);
26844 // debug statements here
26846 // uint64_t Future_clone_ptr(LDKFuture *NONNULL_PTR arg);
26848 export function Future_clone_ptr(arg: bigint): bigint {
26849 if(!isWasmInitialized) {
26850 throw new Error("initializeWasm() must be awaited first!");
26852 const nativeResponseValue = wasm.TS_Future_clone_ptr(arg);
26853 return nativeResponseValue;
26855 // struct LDKFuture Future_clone(const struct LDKFuture *NONNULL_PTR orig);
26857 export function Future_clone(orig: bigint): bigint {
26858 if(!isWasmInitialized) {
26859 throw new Error("initializeWasm() must be awaited first!");
26861 const nativeResponseValue = wasm.TS_Future_clone(orig);
26862 return nativeResponseValue;
26864 // void Future_register_callback_fn(const struct LDKFuture *NONNULL_PTR this_arg, struct LDKFutureCallback callback);
26866 export function Future_register_callback_fn(this_arg: bigint, callback: bigint): void {
26867 if(!isWasmInitialized) {
26868 throw new Error("initializeWasm() must be awaited first!");
26870 const nativeResponseValue = wasm.TS_Future_register_callback_fn(this_arg, callback);
26871 // debug statements here
26873 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
26875 export function Level_clone(orig: bigint): Level {
26876 if(!isWasmInitialized) {
26877 throw new Error("initializeWasm() must be awaited first!");
26879 const nativeResponseValue = wasm.TS_Level_clone(orig);
26880 return nativeResponseValue;
26882 // enum LDKLevel Level_gossip(void);
26884 export function Level_gossip(): Level {
26885 if(!isWasmInitialized) {
26886 throw new Error("initializeWasm() must be awaited first!");
26888 const nativeResponseValue = wasm.TS_Level_gossip();
26889 return nativeResponseValue;
26891 // enum LDKLevel Level_trace(void);
26893 export function Level_trace(): Level {
26894 if(!isWasmInitialized) {
26895 throw new Error("initializeWasm() must be awaited first!");
26897 const nativeResponseValue = wasm.TS_Level_trace();
26898 return nativeResponseValue;
26900 // enum LDKLevel Level_debug(void);
26902 export function Level_debug(): Level {
26903 if(!isWasmInitialized) {
26904 throw new Error("initializeWasm() must be awaited first!");
26906 const nativeResponseValue = wasm.TS_Level_debug();
26907 return nativeResponseValue;
26909 // enum LDKLevel Level_info(void);
26911 export function Level_info(): Level {
26912 if(!isWasmInitialized) {
26913 throw new Error("initializeWasm() must be awaited first!");
26915 const nativeResponseValue = wasm.TS_Level_info();
26916 return nativeResponseValue;
26918 // enum LDKLevel Level_warn(void);
26920 export function Level_warn(): Level {
26921 if(!isWasmInitialized) {
26922 throw new Error("initializeWasm() must be awaited first!");
26924 const nativeResponseValue = wasm.TS_Level_warn();
26925 return nativeResponseValue;
26927 // enum LDKLevel Level_error(void);
26929 export function Level_error(): Level {
26930 if(!isWasmInitialized) {
26931 throw new Error("initializeWasm() must be awaited first!");
26933 const nativeResponseValue = wasm.TS_Level_error();
26934 return nativeResponseValue;
26936 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
26938 export function Level_eq(a: bigint, b: bigint): boolean {
26939 if(!isWasmInitialized) {
26940 throw new Error("initializeWasm() must be awaited first!");
26942 const nativeResponseValue = wasm.TS_Level_eq(a, b);
26943 return nativeResponseValue;
26945 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
26947 export function Level_hash(o: bigint): bigint {
26948 if(!isWasmInitialized) {
26949 throw new Error("initializeWasm() must be awaited first!");
26951 const nativeResponseValue = wasm.TS_Level_hash(o);
26952 return nativeResponseValue;
26954 // MUST_USE_RES enum LDKLevel Level_max(void);
26956 export function Level_max(): Level {
26957 if(!isWasmInitialized) {
26958 throw new Error("initializeWasm() must be awaited first!");
26960 const nativeResponseValue = wasm.TS_Level_max();
26961 return nativeResponseValue;
26963 // void Record_free(struct LDKRecord this_obj);
26965 export function Record_free(this_obj: bigint): void {
26966 if(!isWasmInitialized) {
26967 throw new Error("initializeWasm() must be awaited first!");
26969 const nativeResponseValue = wasm.TS_Record_free(this_obj);
26970 // debug statements here
26972 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
26974 export function Record_get_level(this_ptr: bigint): Level {
26975 if(!isWasmInitialized) {
26976 throw new Error("initializeWasm() must be awaited first!");
26978 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
26979 return nativeResponseValue;
26981 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
26983 export function Record_set_level(this_ptr: bigint, val: Level): void {
26984 if(!isWasmInitialized) {
26985 throw new Error("initializeWasm() must be awaited first!");
26987 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
26988 // debug statements here
26990 // struct LDKPublicKey Record_get_peer_id(const struct LDKRecord *NONNULL_PTR this_ptr);
26992 export function Record_get_peer_id(this_ptr: bigint): number {
26993 if(!isWasmInitialized) {
26994 throw new Error("initializeWasm() must be awaited first!");
26996 const nativeResponseValue = wasm.TS_Record_get_peer_id(this_ptr);
26997 return nativeResponseValue;
26999 // void Record_set_peer_id(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27001 export function Record_set_peer_id(this_ptr: bigint, val: number): void {
27002 if(!isWasmInitialized) {
27003 throw new Error("initializeWasm() must be awaited first!");
27005 const nativeResponseValue = wasm.TS_Record_set_peer_id(this_ptr, val);
27006 // debug statements here
27008 // struct LDKCOption_ThirtyTwoBytesZ Record_get_channel_id(const struct LDKRecord *NONNULL_PTR this_ptr);
27010 export function Record_get_channel_id(this_ptr: bigint): bigint {
27011 if(!isWasmInitialized) {
27012 throw new Error("initializeWasm() must be awaited first!");
27014 const nativeResponseValue = wasm.TS_Record_get_channel_id(this_ptr);
27015 return nativeResponseValue;
27017 // void Record_set_channel_id(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
27019 export function Record_set_channel_id(this_ptr: bigint, val: bigint): void {
27020 if(!isWasmInitialized) {
27021 throw new Error("initializeWasm() must be awaited first!");
27023 const nativeResponseValue = wasm.TS_Record_set_channel_id(this_ptr, val);
27024 // debug statements here
27026 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
27028 export function Record_get_args(this_ptr: bigint): number {
27029 if(!isWasmInitialized) {
27030 throw new Error("initializeWasm() must be awaited first!");
27032 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
27033 return nativeResponseValue;
27035 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
27037 export function Record_set_args(this_ptr: bigint, val: number): void {
27038 if(!isWasmInitialized) {
27039 throw new Error("initializeWasm() must be awaited first!");
27041 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
27042 // debug statements here
27044 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
27046 export function Record_get_module_path(this_ptr: bigint): number {
27047 if(!isWasmInitialized) {
27048 throw new Error("initializeWasm() must be awaited first!");
27050 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
27051 return nativeResponseValue;
27053 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
27055 export function Record_set_module_path(this_ptr: bigint, val: number): void {
27056 if(!isWasmInitialized) {
27057 throw new Error("initializeWasm() must be awaited first!");
27059 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
27060 // debug statements here
27062 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
27064 export function Record_get_file(this_ptr: bigint): number {
27065 if(!isWasmInitialized) {
27066 throw new Error("initializeWasm() must be awaited first!");
27068 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
27069 return nativeResponseValue;
27071 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
27073 export function Record_set_file(this_ptr: bigint, val: number): void {
27074 if(!isWasmInitialized) {
27075 throw new Error("initializeWasm() must be awaited first!");
27077 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
27078 // debug statements here
27080 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
27082 export function Record_get_line(this_ptr: bigint): number {
27083 if(!isWasmInitialized) {
27084 throw new Error("initializeWasm() must be awaited first!");
27086 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
27087 return nativeResponseValue;
27089 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
27091 export function Record_set_line(this_ptr: bigint, val: number): void {
27092 if(!isWasmInitialized) {
27093 throw new Error("initializeWasm() must be awaited first!");
27095 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
27096 // debug statements here
27098 // MUST_USE_RES struct LDKRecord Record_new(enum LDKLevel level_arg, struct LDKPublicKey peer_id_arg, struct LDKCOption_ThirtyTwoBytesZ channel_id_arg, struct LDKStr args_arg, struct LDKStr module_path_arg, struct LDKStr file_arg, uint32_t line_arg);
27100 export function Record_new(level_arg: Level, peer_id_arg: number, channel_id_arg: bigint, args_arg: number, module_path_arg: number, file_arg: number, line_arg: number): bigint {
27101 if(!isWasmInitialized) {
27102 throw new Error("initializeWasm() must be awaited first!");
27104 const nativeResponseValue = wasm.TS_Record_new(level_arg, peer_id_arg, channel_id_arg, args_arg, module_path_arg, file_arg, line_arg);
27105 return nativeResponseValue;
27107 // uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
27109 export function Record_clone_ptr(arg: bigint): bigint {
27110 if(!isWasmInitialized) {
27111 throw new Error("initializeWasm() must be awaited first!");
27113 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
27114 return nativeResponseValue;
27116 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
27118 export function Record_clone(orig: bigint): bigint {
27119 if(!isWasmInitialized) {
27120 throw new Error("initializeWasm() must be awaited first!");
27122 const nativeResponseValue = wasm.TS_Record_clone(orig);
27123 return nativeResponseValue;
27125 // void Logger_free(struct LDKLogger this_ptr);
27127 export function Logger_free(this_ptr: bigint): void {
27128 if(!isWasmInitialized) {
27129 throw new Error("initializeWasm() must be awaited first!");
27131 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
27132 // debug statements here
27134 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
27136 export function ChannelHandshakeConfig_free(this_obj: bigint): void {
27137 if(!isWasmInitialized) {
27138 throw new Error("initializeWasm() must be awaited first!");
27140 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
27141 // debug statements here
27143 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
27145 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: bigint): number {
27146 if(!isWasmInitialized) {
27147 throw new Error("initializeWasm() must be awaited first!");
27149 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
27150 return nativeResponseValue;
27152 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
27154 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: bigint, val: number): void {
27155 if(!isWasmInitialized) {
27156 throw new Error("initializeWasm() must be awaited first!");
27158 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
27159 // debug statements here
27161 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
27163 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: bigint): number {
27164 if(!isWasmInitialized) {
27165 throw new Error("initializeWasm() must be awaited first!");
27167 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
27168 return nativeResponseValue;
27170 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
27172 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: bigint, val: number): void {
27173 if(!isWasmInitialized) {
27174 throw new Error("initializeWasm() must be awaited first!");
27176 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
27177 // debug statements here
27179 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
27181 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: bigint): bigint {
27182 if(!isWasmInitialized) {
27183 throw new Error("initializeWasm() must be awaited first!");
27185 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
27186 return nativeResponseValue;
27188 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
27190 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
27191 if(!isWasmInitialized) {
27192 throw new Error("initializeWasm() must be awaited first!");
27194 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
27195 // debug statements here
27197 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
27199 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint): number {
27200 if(!isWasmInitialized) {
27201 throw new Error("initializeWasm() must be awaited first!");
27203 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
27204 return nativeResponseValue;
27206 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
27208 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: bigint, val: number): void {
27209 if(!isWasmInitialized) {
27210 throw new Error("initializeWasm() must be awaited first!");
27212 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
27213 // debug statements here
27215 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
27217 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: bigint): boolean {
27218 if(!isWasmInitialized) {
27219 throw new Error("initializeWasm() must be awaited first!");
27221 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
27222 return nativeResponseValue;
27224 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
27226 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: bigint, val: boolean): void {
27227 if(!isWasmInitialized) {
27228 throw new Error("initializeWasm() must be awaited first!");
27230 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
27231 // debug statements here
27233 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
27235 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: bigint): boolean {
27236 if(!isWasmInitialized) {
27237 throw new Error("initializeWasm() must be awaited first!");
27239 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
27240 return nativeResponseValue;
27242 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
27244 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: bigint, val: boolean): void {
27245 if(!isWasmInitialized) {
27246 throw new Error("initializeWasm() must be awaited first!");
27248 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
27249 // debug statements here
27251 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
27253 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: bigint): boolean {
27254 if(!isWasmInitialized) {
27255 throw new Error("initializeWasm() must be awaited first!");
27257 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
27258 return nativeResponseValue;
27260 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
27262 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: bigint, val: boolean): void {
27263 if(!isWasmInitialized) {
27264 throw new Error("initializeWasm() must be awaited first!");
27266 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
27267 // debug statements here
27269 // uint32_t ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
27271 export function ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr: bigint): number {
27272 if(!isWasmInitialized) {
27273 throw new Error("initializeWasm() must be awaited first!");
27275 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(this_ptr);
27276 return nativeResponseValue;
27278 // void ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
27280 export function ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr: bigint, val: number): void {
27281 if(!isWasmInitialized) {
27282 throw new Error("initializeWasm() must be awaited first!");
27284 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(this_ptr, val);
27285 // debug statements here
27287 // bool ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
27289 export function ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(this_ptr: bigint): boolean {
27290 if(!isWasmInitialized) {
27291 throw new Error("initializeWasm() must be awaited first!");
27293 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(this_ptr);
27294 return nativeResponseValue;
27296 // void ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
27298 export function ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(this_ptr: bigint, val: boolean): void {
27299 if(!isWasmInitialized) {
27300 throw new Error("initializeWasm() must be awaited first!");
27302 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(this_ptr, val);
27303 // debug statements here
27305 // uint16_t ChannelHandshakeConfig_get_our_max_accepted_htlcs(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
27307 export function ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr: bigint): number {
27308 if(!isWasmInitialized) {
27309 throw new Error("initializeWasm() must be awaited first!");
27311 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs(this_ptr);
27312 return nativeResponseValue;
27314 // void ChannelHandshakeConfig_set_our_max_accepted_htlcs(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
27316 export function ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr: bigint, val: number): void {
27317 if(!isWasmInitialized) {
27318 throw new Error("initializeWasm() must be awaited first!");
27320 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_max_accepted_htlcs(this_ptr, val);
27321 // debug statements here
27323 // 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);
27325 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 {
27326 if(!isWasmInitialized) {
27327 throw new Error("initializeWasm() must be awaited first!");
27329 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);
27330 return nativeResponseValue;
27332 // uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
27334 export function ChannelHandshakeConfig_clone_ptr(arg: bigint): bigint {
27335 if(!isWasmInitialized) {
27336 throw new Error("initializeWasm() must be awaited first!");
27338 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
27339 return nativeResponseValue;
27341 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
27343 export function ChannelHandshakeConfig_clone(orig: bigint): bigint {
27344 if(!isWasmInitialized) {
27345 throw new Error("initializeWasm() must be awaited first!");
27347 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
27348 return nativeResponseValue;
27350 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
27352 export function ChannelHandshakeConfig_default(): bigint {
27353 if(!isWasmInitialized) {
27354 throw new Error("initializeWasm() must be awaited first!");
27356 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
27357 return nativeResponseValue;
27359 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
27361 export function ChannelHandshakeLimits_free(this_obj: bigint): void {
27362 if(!isWasmInitialized) {
27363 throw new Error("initializeWasm() must be awaited first!");
27365 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
27366 // debug statements here
27368 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
27370 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: bigint): bigint {
27371 if(!isWasmInitialized) {
27372 throw new Error("initializeWasm() must be awaited first!");
27374 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
27375 return nativeResponseValue;
27377 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
27379 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: bigint, val: bigint): void {
27380 if(!isWasmInitialized) {
27381 throw new Error("initializeWasm() must be awaited first!");
27383 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
27384 // debug statements here
27386 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
27388 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: bigint): bigint {
27389 if(!isWasmInitialized) {
27390 throw new Error("initializeWasm() must be awaited first!");
27392 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
27393 return nativeResponseValue;
27395 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
27397 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: bigint, val: bigint): void {
27398 if(!isWasmInitialized) {
27399 throw new Error("initializeWasm() must be awaited first!");
27401 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
27402 // debug statements here
27404 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
27406 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: bigint): bigint {
27407 if(!isWasmInitialized) {
27408 throw new Error("initializeWasm() must be awaited first!");
27410 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
27411 return nativeResponseValue;
27413 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
27415 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
27416 if(!isWasmInitialized) {
27417 throw new Error("initializeWasm() must be awaited first!");
27419 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
27420 // debug statements here
27422 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
27424 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
27425 if(!isWasmInitialized) {
27426 throw new Error("initializeWasm() must be awaited first!");
27428 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
27429 return nativeResponseValue;
27431 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
27433 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
27434 if(!isWasmInitialized) {
27435 throw new Error("initializeWasm() must be awaited first!");
27437 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
27438 // debug statements here
27440 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
27442 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: bigint): bigint {
27443 if(!isWasmInitialized) {
27444 throw new Error("initializeWasm() must be awaited first!");
27446 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
27447 return nativeResponseValue;
27449 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
27451 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
27452 if(!isWasmInitialized) {
27453 throw new Error("initializeWasm() must be awaited first!");
27455 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
27456 // debug statements here
27458 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
27460 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: bigint): number {
27461 if(!isWasmInitialized) {
27462 throw new Error("initializeWasm() must be awaited first!");
27464 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
27465 return nativeResponseValue;
27467 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
27469 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: bigint, val: number): void {
27470 if(!isWasmInitialized) {
27471 throw new Error("initializeWasm() must be awaited first!");
27473 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
27474 // debug statements here
27476 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
27478 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: bigint): number {
27479 if(!isWasmInitialized) {
27480 throw new Error("initializeWasm() must be awaited first!");
27482 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
27483 return nativeResponseValue;
27485 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
27487 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: bigint, val: number): void {
27488 if(!isWasmInitialized) {
27489 throw new Error("initializeWasm() must be awaited first!");
27491 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
27492 // debug statements here
27494 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
27496 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: bigint): boolean {
27497 if(!isWasmInitialized) {
27498 throw new Error("initializeWasm() must be awaited first!");
27500 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
27501 return nativeResponseValue;
27503 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
27505 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: bigint, val: boolean): void {
27506 if(!isWasmInitialized) {
27507 throw new Error("initializeWasm() must be awaited first!");
27509 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
27510 // debug statements here
27512 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
27514 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: bigint): boolean {
27515 if(!isWasmInitialized) {
27516 throw new Error("initializeWasm() must be awaited first!");
27518 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
27519 return nativeResponseValue;
27521 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
27523 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: bigint, val: boolean): void {
27524 if(!isWasmInitialized) {
27525 throw new Error("initializeWasm() must be awaited first!");
27527 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
27528 // debug statements here
27530 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
27532 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: bigint): number {
27533 if(!isWasmInitialized) {
27534 throw new Error("initializeWasm() must be awaited first!");
27536 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
27537 return nativeResponseValue;
27539 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
27541 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: bigint, val: number): void {
27542 if(!isWasmInitialized) {
27543 throw new Error("initializeWasm() must be awaited first!");
27545 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
27546 // debug statements here
27548 // 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);
27550 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 {
27551 if(!isWasmInitialized) {
27552 throw new Error("initializeWasm() must be awaited first!");
27554 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);
27555 return nativeResponseValue;
27557 // uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
27559 export function ChannelHandshakeLimits_clone_ptr(arg: bigint): bigint {
27560 if(!isWasmInitialized) {
27561 throw new Error("initializeWasm() must be awaited first!");
27563 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
27564 return nativeResponseValue;
27566 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
27568 export function ChannelHandshakeLimits_clone(orig: bigint): bigint {
27569 if(!isWasmInitialized) {
27570 throw new Error("initializeWasm() must be awaited first!");
27572 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
27573 return nativeResponseValue;
27575 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
27577 export function ChannelHandshakeLimits_default(): bigint {
27578 if(!isWasmInitialized) {
27579 throw new Error("initializeWasm() must be awaited first!");
27581 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
27582 return nativeResponseValue;
27584 // void MaxDustHTLCExposure_free(struct LDKMaxDustHTLCExposure this_ptr);
27586 export function MaxDustHTLCExposure_free(this_ptr: bigint): void {
27587 if(!isWasmInitialized) {
27588 throw new Error("initializeWasm() must be awaited first!");
27590 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_free(this_ptr);
27591 // debug statements here
27593 // uint64_t MaxDustHTLCExposure_clone_ptr(LDKMaxDustHTLCExposure *NONNULL_PTR arg);
27595 export function MaxDustHTLCExposure_clone_ptr(arg: bigint): bigint {
27596 if(!isWasmInitialized) {
27597 throw new Error("initializeWasm() must be awaited first!");
27599 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_clone_ptr(arg);
27600 return nativeResponseValue;
27602 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_clone(const struct LDKMaxDustHTLCExposure *NONNULL_PTR orig);
27604 export function MaxDustHTLCExposure_clone(orig: bigint): bigint {
27605 if(!isWasmInitialized) {
27606 throw new Error("initializeWasm() must be awaited first!");
27608 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_clone(orig);
27609 return nativeResponseValue;
27611 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_fixed_limit_msat(uint64_t a);
27613 export function MaxDustHTLCExposure_fixed_limit_msat(a: bigint): bigint {
27614 if(!isWasmInitialized) {
27615 throw new Error("initializeWasm() must be awaited first!");
27617 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_fixed_limit_msat(a);
27618 return nativeResponseValue;
27620 // struct LDKMaxDustHTLCExposure MaxDustHTLCExposure_fee_rate_multiplier(uint64_t a);
27622 export function MaxDustHTLCExposure_fee_rate_multiplier(a: bigint): bigint {
27623 if(!isWasmInitialized) {
27624 throw new Error("initializeWasm() must be awaited first!");
27626 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_fee_rate_multiplier(a);
27627 return nativeResponseValue;
27629 // bool MaxDustHTLCExposure_eq(const struct LDKMaxDustHTLCExposure *NONNULL_PTR a, const struct LDKMaxDustHTLCExposure *NONNULL_PTR b);
27631 export function MaxDustHTLCExposure_eq(a: bigint, b: bigint): boolean {
27632 if(!isWasmInitialized) {
27633 throw new Error("initializeWasm() must be awaited first!");
27635 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_eq(a, b);
27636 return nativeResponseValue;
27638 // struct LDKCVec_u8Z MaxDustHTLCExposure_write(const struct LDKMaxDustHTLCExposure *NONNULL_PTR obj);
27640 export function MaxDustHTLCExposure_write(obj: bigint): number {
27641 if(!isWasmInitialized) {
27642 throw new Error("initializeWasm() must be awaited first!");
27644 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_write(obj);
27645 return nativeResponseValue;
27647 // struct LDKCResult_MaxDustHTLCExposureDecodeErrorZ MaxDustHTLCExposure_read(struct LDKu8slice ser);
27649 export function MaxDustHTLCExposure_read(ser: number): bigint {
27650 if(!isWasmInitialized) {
27651 throw new Error("initializeWasm() must be awaited first!");
27653 const nativeResponseValue = wasm.TS_MaxDustHTLCExposure_read(ser);
27654 return nativeResponseValue;
27656 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
27658 export function ChannelConfig_free(this_obj: bigint): void {
27659 if(!isWasmInitialized) {
27660 throw new Error("initializeWasm() must be awaited first!");
27662 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
27663 // debug statements here
27665 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
27667 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: bigint): number {
27668 if(!isWasmInitialized) {
27669 throw new Error("initializeWasm() must be awaited first!");
27671 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
27672 return nativeResponseValue;
27674 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
27676 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: number): void {
27677 if(!isWasmInitialized) {
27678 throw new Error("initializeWasm() must be awaited first!");
27680 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
27681 // debug statements here
27683 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
27685 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: bigint): number {
27686 if(!isWasmInitialized) {
27687 throw new Error("initializeWasm() must be awaited first!");
27689 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
27690 return nativeResponseValue;
27692 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
27694 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: bigint, val: number): void {
27695 if(!isWasmInitialized) {
27696 throw new Error("initializeWasm() must be awaited first!");
27698 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
27699 // debug statements here
27701 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
27703 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: bigint): number {
27704 if(!isWasmInitialized) {
27705 throw new Error("initializeWasm() must be awaited first!");
27707 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
27708 return nativeResponseValue;
27710 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
27712 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
27713 if(!isWasmInitialized) {
27714 throw new Error("initializeWasm() must be awaited first!");
27716 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
27717 // debug statements here
27719 // struct LDKMaxDustHTLCExposure ChannelConfig_get_max_dust_htlc_exposure(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
27721 export function ChannelConfig_get_max_dust_htlc_exposure(this_ptr: bigint): bigint {
27722 if(!isWasmInitialized) {
27723 throw new Error("initializeWasm() must be awaited first!");
27725 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure(this_ptr);
27726 return nativeResponseValue;
27728 // void ChannelConfig_set_max_dust_htlc_exposure(struct LDKChannelConfig *NONNULL_PTR this_ptr, struct LDKMaxDustHTLCExposure val);
27730 export function ChannelConfig_set_max_dust_htlc_exposure(this_ptr: bigint, val: bigint): void {
27731 if(!isWasmInitialized) {
27732 throw new Error("initializeWasm() must be awaited first!");
27734 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure(this_ptr, val);
27735 // debug statements here
27737 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
27739 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
27740 if(!isWasmInitialized) {
27741 throw new Error("initializeWasm() must be awaited first!");
27743 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
27744 return nativeResponseValue;
27746 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
27748 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
27749 if(!isWasmInitialized) {
27750 throw new Error("initializeWasm() must be awaited first!");
27752 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
27753 // debug statements here
27755 // bool ChannelConfig_get_accept_underpaying_htlcs(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
27757 export function ChannelConfig_get_accept_underpaying_htlcs(this_ptr: bigint): boolean {
27758 if(!isWasmInitialized) {
27759 throw new Error("initializeWasm() must be awaited first!");
27761 const nativeResponseValue = wasm.TS_ChannelConfig_get_accept_underpaying_htlcs(this_ptr);
27762 return nativeResponseValue;
27764 // void ChannelConfig_set_accept_underpaying_htlcs(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
27766 export function ChannelConfig_set_accept_underpaying_htlcs(this_ptr: bigint, val: boolean): void {
27767 if(!isWasmInitialized) {
27768 throw new Error("initializeWasm() must be awaited first!");
27770 const nativeResponseValue = wasm.TS_ChannelConfig_set_accept_underpaying_htlcs(this_ptr, val);
27771 // debug statements here
27773 // 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);
27775 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 {
27776 if(!isWasmInitialized) {
27777 throw new Error("initializeWasm() must be awaited first!");
27779 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);
27780 return nativeResponseValue;
27782 // uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
27784 export function ChannelConfig_clone_ptr(arg: bigint): bigint {
27785 if(!isWasmInitialized) {
27786 throw new Error("initializeWasm() must be awaited first!");
27788 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
27789 return nativeResponseValue;
27791 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
27793 export function ChannelConfig_clone(orig: bigint): bigint {
27794 if(!isWasmInitialized) {
27795 throw new Error("initializeWasm() must be awaited first!");
27797 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
27798 return nativeResponseValue;
27800 // bool ChannelConfig_eq(const struct LDKChannelConfig *NONNULL_PTR a, const struct LDKChannelConfig *NONNULL_PTR b);
27802 export function ChannelConfig_eq(a: bigint, b: bigint): boolean {
27803 if(!isWasmInitialized) {
27804 throw new Error("initializeWasm() must be awaited first!");
27806 const nativeResponseValue = wasm.TS_ChannelConfig_eq(a, b);
27807 return nativeResponseValue;
27809 // void ChannelConfig_apply(struct LDKChannelConfig *NONNULL_PTR this_arg, const struct LDKChannelConfigUpdate *NONNULL_PTR update);
27811 export function ChannelConfig_apply(this_arg: bigint, update: bigint): void {
27812 if(!isWasmInitialized) {
27813 throw new Error("initializeWasm() must be awaited first!");
27815 const nativeResponseValue = wasm.TS_ChannelConfig_apply(this_arg, update);
27816 // debug statements here
27818 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
27820 export function ChannelConfig_default(): bigint {
27821 if(!isWasmInitialized) {
27822 throw new Error("initializeWasm() must be awaited first!");
27824 const nativeResponseValue = wasm.TS_ChannelConfig_default();
27825 return nativeResponseValue;
27827 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
27829 export function ChannelConfig_write(obj: bigint): number {
27830 if(!isWasmInitialized) {
27831 throw new Error("initializeWasm() must be awaited first!");
27833 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
27834 return nativeResponseValue;
27836 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
27838 export function ChannelConfig_read(ser: number): bigint {
27839 if(!isWasmInitialized) {
27840 throw new Error("initializeWasm() must be awaited first!");
27842 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
27843 return nativeResponseValue;
27845 // void ChannelConfigUpdate_free(struct LDKChannelConfigUpdate this_obj);
27847 export function ChannelConfigUpdate_free(this_obj: bigint): void {
27848 if(!isWasmInitialized) {
27849 throw new Error("initializeWasm() must be awaited first!");
27851 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_free(this_obj);
27852 // debug statements here
27854 // struct LDKCOption_u32Z ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
27856 export function ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(this_ptr: bigint): bigint {
27857 if(!isWasmInitialized) {
27858 throw new Error("initializeWasm() must be awaited first!");
27860 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(this_ptr);
27861 return nativeResponseValue;
27863 // void ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
27865 export function ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(this_ptr: bigint, val: bigint): void {
27866 if(!isWasmInitialized) {
27867 throw new Error("initializeWasm() must be awaited first!");
27869 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(this_ptr, val);
27870 // debug statements here
27872 // struct LDKCOption_u32Z ChannelConfigUpdate_get_forwarding_fee_base_msat(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
27874 export function ChannelConfigUpdate_get_forwarding_fee_base_msat(this_ptr: bigint): bigint {
27875 if(!isWasmInitialized) {
27876 throw new Error("initializeWasm() must be awaited first!");
27878 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_forwarding_fee_base_msat(this_ptr);
27879 return nativeResponseValue;
27881 // void ChannelConfigUpdate_set_forwarding_fee_base_msat(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
27883 export function ChannelConfigUpdate_set_forwarding_fee_base_msat(this_ptr: bigint, val: bigint): void {
27884 if(!isWasmInitialized) {
27885 throw new Error("initializeWasm() must be awaited first!");
27887 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_forwarding_fee_base_msat(this_ptr, val);
27888 // debug statements here
27890 // struct LDKCOption_u16Z ChannelConfigUpdate_get_cltv_expiry_delta(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
27892 export function ChannelConfigUpdate_get_cltv_expiry_delta(this_ptr: bigint): bigint {
27893 if(!isWasmInitialized) {
27894 throw new Error("initializeWasm() must be awaited first!");
27896 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_cltv_expiry_delta(this_ptr);
27897 return nativeResponseValue;
27899 // void ChannelConfigUpdate_set_cltv_expiry_delta(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
27901 export function ChannelConfigUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: bigint): void {
27902 if(!isWasmInitialized) {
27903 throw new Error("initializeWasm() must be awaited first!");
27905 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_cltv_expiry_delta(this_ptr, val);
27906 // debug statements here
27908 // struct LDKCOption_MaxDustHTLCExposureZ ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
27910 export function ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(this_ptr: bigint): bigint {
27911 if(!isWasmInitialized) {
27912 throw new Error("initializeWasm() must be awaited first!");
27914 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(this_ptr);
27915 return nativeResponseValue;
27917 // void ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_MaxDustHTLCExposureZ val);
27919 export function ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(this_ptr: bigint, val: bigint): void {
27920 if(!isWasmInitialized) {
27921 throw new Error("initializeWasm() must be awaited first!");
27923 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(this_ptr, val);
27924 // debug statements here
27926 // struct LDKCOption_u64Z ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr);
27928 export function ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(this_ptr: bigint): bigint {
27929 if(!isWasmInitialized) {
27930 throw new Error("initializeWasm() must be awaited first!");
27932 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(this_ptr);
27933 return nativeResponseValue;
27935 // void ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfigUpdate *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
27937 export function ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
27938 if(!isWasmInitialized) {
27939 throw new Error("initializeWasm() must be awaited first!");
27941 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
27942 // debug statements here
27944 // 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);
27946 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 {
27947 if(!isWasmInitialized) {
27948 throw new Error("initializeWasm() must be awaited first!");
27950 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);
27951 return nativeResponseValue;
27953 // MUST_USE_RES struct LDKChannelConfigUpdate ChannelConfigUpdate_default(void);
27955 export function ChannelConfigUpdate_default(): bigint {
27956 if(!isWasmInitialized) {
27957 throw new Error("initializeWasm() must be awaited first!");
27959 const nativeResponseValue = wasm.TS_ChannelConfigUpdate_default();
27960 return nativeResponseValue;
27962 // void UserConfig_free(struct LDKUserConfig this_obj);
27964 export function UserConfig_free(this_obj: bigint): void {
27965 if(!isWasmInitialized) {
27966 throw new Error("initializeWasm() must be awaited first!");
27968 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
27969 // debug statements here
27971 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
27973 export function UserConfig_get_channel_handshake_config(this_ptr: bigint): bigint {
27974 if(!isWasmInitialized) {
27975 throw new Error("initializeWasm() must be awaited first!");
27977 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
27978 return nativeResponseValue;
27980 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
27982 export function UserConfig_set_channel_handshake_config(this_ptr: bigint, val: bigint): void {
27983 if(!isWasmInitialized) {
27984 throw new Error("initializeWasm() must be awaited first!");
27986 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
27987 // debug statements here
27989 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
27991 export function UserConfig_get_channel_handshake_limits(this_ptr: bigint): bigint {
27992 if(!isWasmInitialized) {
27993 throw new Error("initializeWasm() must be awaited first!");
27995 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
27996 return nativeResponseValue;
27998 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
28000 export function UserConfig_set_channel_handshake_limits(this_ptr: bigint, val: bigint): void {
28001 if(!isWasmInitialized) {
28002 throw new Error("initializeWasm() must be awaited first!");
28004 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
28005 // debug statements here
28007 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
28009 export function UserConfig_get_channel_config(this_ptr: bigint): bigint {
28010 if(!isWasmInitialized) {
28011 throw new Error("initializeWasm() must be awaited first!");
28013 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
28014 return nativeResponseValue;
28016 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
28018 export function UserConfig_set_channel_config(this_ptr: bigint, val: bigint): void {
28019 if(!isWasmInitialized) {
28020 throw new Error("initializeWasm() must be awaited first!");
28022 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
28023 // debug statements here
28025 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
28027 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: bigint): boolean {
28028 if(!isWasmInitialized) {
28029 throw new Error("initializeWasm() must be awaited first!");
28031 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
28032 return nativeResponseValue;
28034 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
28036 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: bigint, val: boolean): void {
28037 if(!isWasmInitialized) {
28038 throw new Error("initializeWasm() must be awaited first!");
28040 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
28041 // debug statements here
28043 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
28045 export function UserConfig_get_accept_inbound_channels(this_ptr: bigint): boolean {
28046 if(!isWasmInitialized) {
28047 throw new Error("initializeWasm() must be awaited first!");
28049 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
28050 return nativeResponseValue;
28052 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
28054 export function UserConfig_set_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
28055 if(!isWasmInitialized) {
28056 throw new Error("initializeWasm() must be awaited first!");
28058 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
28059 // debug statements here
28061 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
28063 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: bigint): boolean {
28064 if(!isWasmInitialized) {
28065 throw new Error("initializeWasm() must be awaited first!");
28067 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
28068 return nativeResponseValue;
28070 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
28072 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: bigint, val: boolean): void {
28073 if(!isWasmInitialized) {
28074 throw new Error("initializeWasm() must be awaited first!");
28076 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
28077 // debug statements here
28079 // bool UserConfig_get_accept_intercept_htlcs(const struct LDKUserConfig *NONNULL_PTR this_ptr);
28081 export function UserConfig_get_accept_intercept_htlcs(this_ptr: bigint): boolean {
28082 if(!isWasmInitialized) {
28083 throw new Error("initializeWasm() must be awaited first!");
28085 const nativeResponseValue = wasm.TS_UserConfig_get_accept_intercept_htlcs(this_ptr);
28086 return nativeResponseValue;
28088 // void UserConfig_set_accept_intercept_htlcs(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
28090 export function UserConfig_set_accept_intercept_htlcs(this_ptr: bigint, val: boolean): void {
28091 if(!isWasmInitialized) {
28092 throw new Error("initializeWasm() must be awaited first!");
28094 const nativeResponseValue = wasm.TS_UserConfig_set_accept_intercept_htlcs(this_ptr, val);
28095 // debug statements here
28097 // bool UserConfig_get_accept_mpp_keysend(const struct LDKUserConfig *NONNULL_PTR this_ptr);
28099 export function UserConfig_get_accept_mpp_keysend(this_ptr: bigint): boolean {
28100 if(!isWasmInitialized) {
28101 throw new Error("initializeWasm() must be awaited first!");
28103 const nativeResponseValue = wasm.TS_UserConfig_get_accept_mpp_keysend(this_ptr);
28104 return nativeResponseValue;
28106 // void UserConfig_set_accept_mpp_keysend(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
28108 export function UserConfig_set_accept_mpp_keysend(this_ptr: bigint, val: boolean): void {
28109 if(!isWasmInitialized) {
28110 throw new Error("initializeWasm() must be awaited first!");
28112 const nativeResponseValue = wasm.TS_UserConfig_set_accept_mpp_keysend(this_ptr, val);
28113 // debug statements here
28115 // 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);
28117 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 {
28118 if(!isWasmInitialized) {
28119 throw new Error("initializeWasm() must be awaited first!");
28121 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);
28122 return nativeResponseValue;
28124 // uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
28126 export function UserConfig_clone_ptr(arg: bigint): bigint {
28127 if(!isWasmInitialized) {
28128 throw new Error("initializeWasm() must be awaited first!");
28130 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
28131 return nativeResponseValue;
28133 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
28135 export function UserConfig_clone(orig: bigint): bigint {
28136 if(!isWasmInitialized) {
28137 throw new Error("initializeWasm() must be awaited first!");
28139 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
28140 return nativeResponseValue;
28142 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
28144 export function UserConfig_default(): bigint {
28145 if(!isWasmInitialized) {
28146 throw new Error("initializeWasm() must be awaited first!");
28148 const nativeResponseValue = wasm.TS_UserConfig_default();
28149 return nativeResponseValue;
28151 // void BestBlock_free(struct LDKBestBlock this_obj);
28153 export function BestBlock_free(this_obj: bigint): void {
28154 if(!isWasmInitialized) {
28155 throw new Error("initializeWasm() must be awaited first!");
28157 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
28158 // debug statements here
28160 // uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
28162 export function BestBlock_clone_ptr(arg: bigint): bigint {
28163 if(!isWasmInitialized) {
28164 throw new Error("initializeWasm() must be awaited first!");
28166 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
28167 return nativeResponseValue;
28169 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
28171 export function BestBlock_clone(orig: bigint): bigint {
28172 if(!isWasmInitialized) {
28173 throw new Error("initializeWasm() must be awaited first!");
28175 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
28176 return nativeResponseValue;
28178 // bool BestBlock_eq(const struct LDKBestBlock *NONNULL_PTR a, const struct LDKBestBlock *NONNULL_PTR b);
28180 export function BestBlock_eq(a: bigint, b: bigint): boolean {
28181 if(!isWasmInitialized) {
28182 throw new Error("initializeWasm() must be awaited first!");
28184 const nativeResponseValue = wasm.TS_BestBlock_eq(a, b);
28185 return nativeResponseValue;
28187 // MUST_USE_RES struct LDKBestBlock BestBlock_from_network(enum LDKNetwork network);
28189 export function BestBlock_from_network(network: Network): bigint {
28190 if(!isWasmInitialized) {
28191 throw new Error("initializeWasm() must be awaited first!");
28193 const nativeResponseValue = wasm.TS_BestBlock_from_network(network);
28194 return nativeResponseValue;
28196 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
28198 export function BestBlock_new(block_hash: number, height: number): bigint {
28199 if(!isWasmInitialized) {
28200 throw new Error("initializeWasm() must be awaited first!");
28202 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
28203 return nativeResponseValue;
28205 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
28207 export function BestBlock_block_hash(this_arg: bigint): number {
28208 if(!isWasmInitialized) {
28209 throw new Error("initializeWasm() must be awaited first!");
28211 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
28212 return nativeResponseValue;
28214 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
28216 export function BestBlock_height(this_arg: bigint): number {
28217 if(!isWasmInitialized) {
28218 throw new Error("initializeWasm() must be awaited first!");
28220 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
28221 return nativeResponseValue;
28223 // void Listen_free(struct LDKListen this_ptr);
28225 export function Listen_free(this_ptr: bigint): void {
28226 if(!isWasmInitialized) {
28227 throw new Error("initializeWasm() must be awaited first!");
28229 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
28230 // debug statements here
28232 // void Confirm_free(struct LDKConfirm this_ptr);
28234 export function Confirm_free(this_ptr: bigint): void {
28235 if(!isWasmInitialized) {
28236 throw new Error("initializeWasm() must be awaited first!");
28238 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
28239 // debug statements here
28241 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_clone(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR orig);
28243 export function ChannelMonitorUpdateStatus_clone(orig: bigint): ChannelMonitorUpdateStatus {
28244 if(!isWasmInitialized) {
28245 throw new Error("initializeWasm() must be awaited first!");
28247 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_clone(orig);
28248 return nativeResponseValue;
28250 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_completed(void);
28252 export function ChannelMonitorUpdateStatus_completed(): ChannelMonitorUpdateStatus {
28253 if(!isWasmInitialized) {
28254 throw new Error("initializeWasm() must be awaited first!");
28256 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_completed();
28257 return nativeResponseValue;
28259 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_in_progress(void);
28261 export function ChannelMonitorUpdateStatus_in_progress(): ChannelMonitorUpdateStatus {
28262 if(!isWasmInitialized) {
28263 throw new Error("initializeWasm() must be awaited first!");
28265 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_in_progress();
28266 return nativeResponseValue;
28268 // enum LDKChannelMonitorUpdateStatus ChannelMonitorUpdateStatus_unrecoverable_error(void);
28270 export function ChannelMonitorUpdateStatus_unrecoverable_error(): ChannelMonitorUpdateStatus {
28271 if(!isWasmInitialized) {
28272 throw new Error("initializeWasm() must be awaited first!");
28274 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_unrecoverable_error();
28275 return nativeResponseValue;
28277 // bool ChannelMonitorUpdateStatus_eq(const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR a, const enum LDKChannelMonitorUpdateStatus *NONNULL_PTR b);
28279 export function ChannelMonitorUpdateStatus_eq(a: bigint, b: bigint): boolean {
28280 if(!isWasmInitialized) {
28281 throw new Error("initializeWasm() must be awaited first!");
28283 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateStatus_eq(a, b);
28284 return nativeResponseValue;
28286 // void Watch_free(struct LDKWatch this_ptr);
28288 export function Watch_free(this_ptr: bigint): void {
28289 if(!isWasmInitialized) {
28290 throw new Error("initializeWasm() must be awaited first!");
28292 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
28293 // debug statements here
28295 // void Filter_free(struct LDKFilter this_ptr);
28297 export function Filter_free(this_ptr: bigint): void {
28298 if(!isWasmInitialized) {
28299 throw new Error("initializeWasm() must be awaited first!");
28301 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
28302 // debug statements here
28304 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
28306 export function WatchedOutput_free(this_obj: bigint): void {
28307 if(!isWasmInitialized) {
28308 throw new Error("initializeWasm() must be awaited first!");
28310 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
28311 // debug statements here
28313 // struct LDKCOption_ThirtyTwoBytesZ WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
28315 export function WatchedOutput_get_block_hash(this_ptr: bigint): bigint {
28316 if(!isWasmInitialized) {
28317 throw new Error("initializeWasm() must be awaited first!");
28319 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
28320 return nativeResponseValue;
28322 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
28324 export function WatchedOutput_set_block_hash(this_ptr: bigint, val: bigint): void {
28325 if(!isWasmInitialized) {
28326 throw new Error("initializeWasm() must be awaited first!");
28328 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
28329 // debug statements here
28331 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
28333 export function WatchedOutput_get_outpoint(this_ptr: bigint): bigint {
28334 if(!isWasmInitialized) {
28335 throw new Error("initializeWasm() must be awaited first!");
28337 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
28338 return nativeResponseValue;
28340 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
28342 export function WatchedOutput_set_outpoint(this_ptr: bigint, val: bigint): void {
28343 if(!isWasmInitialized) {
28344 throw new Error("initializeWasm() must be awaited first!");
28346 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
28347 // debug statements here
28349 // struct LDKCVec_u8Z WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
28351 export function WatchedOutput_get_script_pubkey(this_ptr: bigint): number {
28352 if(!isWasmInitialized) {
28353 throw new Error("initializeWasm() must be awaited first!");
28355 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
28356 return nativeResponseValue;
28358 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
28360 export function WatchedOutput_set_script_pubkey(this_ptr: bigint, val: number): void {
28361 if(!isWasmInitialized) {
28362 throw new Error("initializeWasm() must be awaited first!");
28364 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
28365 // debug statements here
28367 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKCOption_ThirtyTwoBytesZ block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
28369 export function WatchedOutput_new(block_hash_arg: bigint, outpoint_arg: bigint, script_pubkey_arg: number): bigint {
28370 if(!isWasmInitialized) {
28371 throw new Error("initializeWasm() must be awaited first!");
28373 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
28374 return nativeResponseValue;
28376 // uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
28378 export function WatchedOutput_clone_ptr(arg: bigint): bigint {
28379 if(!isWasmInitialized) {
28380 throw new Error("initializeWasm() must be awaited first!");
28382 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
28383 return nativeResponseValue;
28385 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
28387 export function WatchedOutput_clone(orig: bigint): bigint {
28388 if(!isWasmInitialized) {
28389 throw new Error("initializeWasm() must be awaited first!");
28391 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
28392 return nativeResponseValue;
28394 // bool WatchedOutput_eq(const struct LDKWatchedOutput *NONNULL_PTR a, const struct LDKWatchedOutput *NONNULL_PTR b);
28396 export function WatchedOutput_eq(a: bigint, b: bigint): boolean {
28397 if(!isWasmInitialized) {
28398 throw new Error("initializeWasm() must be awaited first!");
28400 const nativeResponseValue = wasm.TS_WatchedOutput_eq(a, b);
28401 return nativeResponseValue;
28403 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
28405 export function WatchedOutput_hash(o: bigint): bigint {
28406 if(!isWasmInitialized) {
28407 throw new Error("initializeWasm() must be awaited first!");
28409 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
28410 return nativeResponseValue;
28412 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
28414 export function BroadcasterInterface_free(this_ptr: bigint): void {
28415 if(!isWasmInitialized) {
28416 throw new Error("initializeWasm() must be awaited first!");
28418 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
28419 // debug statements here
28421 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
28423 export function ConfirmationTarget_clone(orig: bigint): ConfirmationTarget {
28424 if(!isWasmInitialized) {
28425 throw new Error("initializeWasm() must be awaited first!");
28427 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
28428 return nativeResponseValue;
28430 // enum LDKConfirmationTarget ConfirmationTarget_on_chain_sweep(void);
28432 export function ConfirmationTarget_on_chain_sweep(): ConfirmationTarget {
28433 if(!isWasmInitialized) {
28434 throw new Error("initializeWasm() must be awaited first!");
28436 const nativeResponseValue = wasm.TS_ConfirmationTarget_on_chain_sweep();
28437 return nativeResponseValue;
28439 // enum LDKConfirmationTarget ConfirmationTarget_min_allowed_anchor_channel_remote_fee(void);
28441 export function ConfirmationTarget_min_allowed_anchor_channel_remote_fee(): ConfirmationTarget {
28442 if(!isWasmInitialized) {
28443 throw new Error("initializeWasm() must be awaited first!");
28445 const nativeResponseValue = wasm.TS_ConfirmationTarget_min_allowed_anchor_channel_remote_fee();
28446 return nativeResponseValue;
28448 // enum LDKConfirmationTarget ConfirmationTarget_min_allowed_non_anchor_channel_remote_fee(void);
28450 export function ConfirmationTarget_min_allowed_non_anchor_channel_remote_fee(): ConfirmationTarget {
28451 if(!isWasmInitialized) {
28452 throw new Error("initializeWasm() must be awaited first!");
28454 const nativeResponseValue = wasm.TS_ConfirmationTarget_min_allowed_non_anchor_channel_remote_fee();
28455 return nativeResponseValue;
28457 // enum LDKConfirmationTarget ConfirmationTarget_anchor_channel_fee(void);
28459 export function ConfirmationTarget_anchor_channel_fee(): ConfirmationTarget {
28460 if(!isWasmInitialized) {
28461 throw new Error("initializeWasm() must be awaited first!");
28463 const nativeResponseValue = wasm.TS_ConfirmationTarget_anchor_channel_fee();
28464 return nativeResponseValue;
28466 // enum LDKConfirmationTarget ConfirmationTarget_non_anchor_channel_fee(void);
28468 export function ConfirmationTarget_non_anchor_channel_fee(): ConfirmationTarget {
28469 if(!isWasmInitialized) {
28470 throw new Error("initializeWasm() must be awaited first!");
28472 const nativeResponseValue = wasm.TS_ConfirmationTarget_non_anchor_channel_fee();
28473 return nativeResponseValue;
28475 // enum LDKConfirmationTarget ConfirmationTarget_channel_close_minimum(void);
28477 export function ConfirmationTarget_channel_close_minimum(): ConfirmationTarget {
28478 if(!isWasmInitialized) {
28479 throw new Error("initializeWasm() must be awaited first!");
28481 const nativeResponseValue = wasm.TS_ConfirmationTarget_channel_close_minimum();
28482 return nativeResponseValue;
28484 // uint64_t ConfirmationTarget_hash(const enum LDKConfirmationTarget *NONNULL_PTR o);
28486 export function ConfirmationTarget_hash(o: bigint): bigint {
28487 if(!isWasmInitialized) {
28488 throw new Error("initializeWasm() must be awaited first!");
28490 const nativeResponseValue = wasm.TS_ConfirmationTarget_hash(o);
28491 return nativeResponseValue;
28493 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
28495 export function ConfirmationTarget_eq(a: bigint, b: bigint): boolean {
28496 if(!isWasmInitialized) {
28497 throw new Error("initializeWasm() must be awaited first!");
28499 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
28500 return nativeResponseValue;
28502 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
28504 export function FeeEstimator_free(this_ptr: bigint): void {
28505 if(!isWasmInitialized) {
28506 throw new Error("initializeWasm() must be awaited first!");
28508 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
28509 // debug statements here
28511 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
28513 export function MonitorUpdateId_free(this_obj: bigint): void {
28514 if(!isWasmInitialized) {
28515 throw new Error("initializeWasm() must be awaited first!");
28517 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
28518 // debug statements here
28520 // uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
28522 export function MonitorUpdateId_clone_ptr(arg: bigint): bigint {
28523 if(!isWasmInitialized) {
28524 throw new Error("initializeWasm() must be awaited first!");
28526 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
28527 return nativeResponseValue;
28529 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
28531 export function MonitorUpdateId_clone(orig: bigint): bigint {
28532 if(!isWasmInitialized) {
28533 throw new Error("initializeWasm() must be awaited first!");
28535 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
28536 return nativeResponseValue;
28538 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
28540 export function MonitorUpdateId_hash(o: bigint): bigint {
28541 if(!isWasmInitialized) {
28542 throw new Error("initializeWasm() must be awaited first!");
28544 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
28545 return nativeResponseValue;
28547 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
28549 export function MonitorUpdateId_eq(a: bigint, b: bigint): boolean {
28550 if(!isWasmInitialized) {
28551 throw new Error("initializeWasm() must be awaited first!");
28553 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
28554 return nativeResponseValue;
28556 // void Persist_free(struct LDKPersist this_ptr);
28558 export function Persist_free(this_ptr: bigint): void {
28559 if(!isWasmInitialized) {
28560 throw new Error("initializeWasm() must be awaited first!");
28562 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
28563 // debug statements here
28565 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
28567 export function LockedChannelMonitor_free(this_obj: bigint): void {
28568 if(!isWasmInitialized) {
28569 throw new Error("initializeWasm() must be awaited first!");
28571 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
28572 // debug statements here
28574 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
28576 export function ChainMonitor_free(this_obj: bigint): void {
28577 if(!isWasmInitialized) {
28578 throw new Error("initializeWasm() must be awaited first!");
28580 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
28581 // debug statements here
28583 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
28585 export function ChainMonitor_new(chain_source: bigint, broadcaster: bigint, logger: bigint, feeest: bigint, persister: bigint): bigint {
28586 if(!isWasmInitialized) {
28587 throw new Error("initializeWasm() must be awaited first!");
28589 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
28590 return nativeResponseValue;
28592 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
28594 export function ChainMonitor_get_claimable_balances(this_arg: bigint, ignored_channels: number): number {
28595 if(!isWasmInitialized) {
28596 throw new Error("initializeWasm() must be awaited first!");
28598 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
28599 return nativeResponseValue;
28601 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
28603 export function ChainMonitor_get_monitor(this_arg: bigint, funding_txo: bigint): bigint {
28604 if(!isWasmInitialized) {
28605 throw new Error("initializeWasm() must be awaited first!");
28607 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
28608 return nativeResponseValue;
28610 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
28612 export function ChainMonitor_list_monitors(this_arg: bigint): number {
28613 if(!isWasmInitialized) {
28614 throw new Error("initializeWasm() must be awaited first!");
28616 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
28617 return nativeResponseValue;
28619 // MUST_USE_RES struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ChainMonitor_list_pending_monitor_updates(const struct LDKChainMonitor *NONNULL_PTR this_arg);
28621 export function ChainMonitor_list_pending_monitor_updates(this_arg: bigint): number {
28622 if(!isWasmInitialized) {
28623 throw new Error("initializeWasm() must be awaited first!");
28625 const nativeResponseValue = wasm.TS_ChainMonitor_list_pending_monitor_updates(this_arg);
28626 return nativeResponseValue;
28628 // 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);
28630 export function ChainMonitor_channel_monitor_updated(this_arg: bigint, funding_txo: bigint, completed_update_id: bigint): bigint {
28631 if(!isWasmInitialized) {
28632 throw new Error("initializeWasm() must be awaited first!");
28634 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
28635 return nativeResponseValue;
28637 // MUST_USE_RES struct LDKFuture ChainMonitor_get_update_future(const struct LDKChainMonitor *NONNULL_PTR this_arg);
28639 export function ChainMonitor_get_update_future(this_arg: bigint): bigint {
28640 if(!isWasmInitialized) {
28641 throw new Error("initializeWasm() must be awaited first!");
28643 const nativeResponseValue = wasm.TS_ChainMonitor_get_update_future(this_arg);
28644 return nativeResponseValue;
28646 // void ChainMonitor_rebroadcast_pending_claims(const struct LDKChainMonitor *NONNULL_PTR this_arg);
28648 export function ChainMonitor_rebroadcast_pending_claims(this_arg: bigint): void {
28649 if(!isWasmInitialized) {
28650 throw new Error("initializeWasm() must be awaited first!");
28652 const nativeResponseValue = wasm.TS_ChainMonitor_rebroadcast_pending_claims(this_arg);
28653 // debug statements here
28655 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
28657 export function ChainMonitor_as_Listen(this_arg: bigint): bigint {
28658 if(!isWasmInitialized) {
28659 throw new Error("initializeWasm() must be awaited first!");
28661 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
28662 return nativeResponseValue;
28664 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
28666 export function ChainMonitor_as_Confirm(this_arg: bigint): bigint {
28667 if(!isWasmInitialized) {
28668 throw new Error("initializeWasm() must be awaited first!");
28670 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
28671 return nativeResponseValue;
28673 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
28675 export function ChainMonitor_as_Watch(this_arg: bigint): bigint {
28676 if(!isWasmInitialized) {
28677 throw new Error("initializeWasm() must be awaited first!");
28679 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
28680 return nativeResponseValue;
28682 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
28684 export function ChainMonitor_as_EventsProvider(this_arg: bigint): bigint {
28685 if(!isWasmInitialized) {
28686 throw new Error("initializeWasm() must be awaited first!");
28688 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
28689 return nativeResponseValue;
28691 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
28693 export function ChannelMonitorUpdate_free(this_obj: bigint): void {
28694 if(!isWasmInitialized) {
28695 throw new Error("initializeWasm() must be awaited first!");
28697 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
28698 // debug statements here
28700 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
28702 export function ChannelMonitorUpdate_get_update_id(this_ptr: bigint): bigint {
28703 if(!isWasmInitialized) {
28704 throw new Error("initializeWasm() must be awaited first!");
28706 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
28707 return nativeResponseValue;
28709 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
28711 export function ChannelMonitorUpdate_set_update_id(this_ptr: bigint, val: bigint): void {
28712 if(!isWasmInitialized) {
28713 throw new Error("initializeWasm() must be awaited first!");
28715 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
28716 // debug statements here
28718 // uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
28720 export function ChannelMonitorUpdate_clone_ptr(arg: bigint): bigint {
28721 if(!isWasmInitialized) {
28722 throw new Error("initializeWasm() must be awaited first!");
28724 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
28725 return nativeResponseValue;
28727 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
28729 export function ChannelMonitorUpdate_clone(orig: bigint): bigint {
28730 if(!isWasmInitialized) {
28731 throw new Error("initializeWasm() must be awaited first!");
28733 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
28734 return nativeResponseValue;
28736 // bool ChannelMonitorUpdate_eq(const struct LDKChannelMonitorUpdate *NONNULL_PTR a, const struct LDKChannelMonitorUpdate *NONNULL_PTR b);
28738 export function ChannelMonitorUpdate_eq(a: bigint, b: bigint): boolean {
28739 if(!isWasmInitialized) {
28740 throw new Error("initializeWasm() must be awaited first!");
28742 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_eq(a, b);
28743 return nativeResponseValue;
28745 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
28747 export function ChannelMonitorUpdate_write(obj: bigint): number {
28748 if(!isWasmInitialized) {
28749 throw new Error("initializeWasm() must be awaited first!");
28751 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
28752 return nativeResponseValue;
28754 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
28756 export function ChannelMonitorUpdate_read(ser: number): bigint {
28757 if(!isWasmInitialized) {
28758 throw new Error("initializeWasm() must be awaited first!");
28760 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
28761 return nativeResponseValue;
28763 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
28765 export function MonitorEvent_free(this_ptr: bigint): void {
28766 if(!isWasmInitialized) {
28767 throw new Error("initializeWasm() must be awaited first!");
28769 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
28770 // debug statements here
28772 // uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
28774 export function MonitorEvent_clone_ptr(arg: bigint): bigint {
28775 if(!isWasmInitialized) {
28776 throw new Error("initializeWasm() must be awaited first!");
28778 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
28779 return nativeResponseValue;
28781 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
28783 export function MonitorEvent_clone(orig: bigint): bigint {
28784 if(!isWasmInitialized) {
28785 throw new Error("initializeWasm() must be awaited first!");
28787 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
28788 return nativeResponseValue;
28790 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
28792 export function MonitorEvent_htlcevent(a: bigint): bigint {
28793 if(!isWasmInitialized) {
28794 throw new Error("initializeWasm() must be awaited first!");
28796 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
28797 return nativeResponseValue;
28799 // struct LDKMonitorEvent MonitorEvent_holder_force_closed(struct LDKOutPoint a);
28801 export function MonitorEvent_holder_force_closed(a: bigint): bigint {
28802 if(!isWasmInitialized) {
28803 throw new Error("initializeWasm() must be awaited first!");
28805 const nativeResponseValue = wasm.TS_MonitorEvent_holder_force_closed(a);
28806 return nativeResponseValue;
28808 // struct LDKMonitorEvent MonitorEvent_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
28810 export function MonitorEvent_completed(funding_txo: bigint, monitor_update_id: bigint): bigint {
28811 if(!isWasmInitialized) {
28812 throw new Error("initializeWasm() must be awaited first!");
28814 const nativeResponseValue = wasm.TS_MonitorEvent_completed(funding_txo, monitor_update_id);
28815 return nativeResponseValue;
28817 // bool MonitorEvent_eq(const struct LDKMonitorEvent *NONNULL_PTR a, const struct LDKMonitorEvent *NONNULL_PTR b);
28819 export function MonitorEvent_eq(a: bigint, b: bigint): boolean {
28820 if(!isWasmInitialized) {
28821 throw new Error("initializeWasm() must be awaited first!");
28823 const nativeResponseValue = wasm.TS_MonitorEvent_eq(a, b);
28824 return nativeResponseValue;
28826 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
28828 export function MonitorEvent_write(obj: bigint): number {
28829 if(!isWasmInitialized) {
28830 throw new Error("initializeWasm() must be awaited first!");
28832 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
28833 return nativeResponseValue;
28835 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
28837 export function MonitorEvent_read(ser: number): bigint {
28838 if(!isWasmInitialized) {
28839 throw new Error("initializeWasm() must be awaited first!");
28841 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
28842 return nativeResponseValue;
28844 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
28846 export function HTLCUpdate_free(this_obj: bigint): void {
28847 if(!isWasmInitialized) {
28848 throw new Error("initializeWasm() must be awaited first!");
28850 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
28851 // debug statements here
28853 // uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
28855 export function HTLCUpdate_clone_ptr(arg: bigint): bigint {
28856 if(!isWasmInitialized) {
28857 throw new Error("initializeWasm() must be awaited first!");
28859 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
28860 return nativeResponseValue;
28862 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
28864 export function HTLCUpdate_clone(orig: bigint): bigint {
28865 if(!isWasmInitialized) {
28866 throw new Error("initializeWasm() must be awaited first!");
28868 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
28869 return nativeResponseValue;
28871 // bool HTLCUpdate_eq(const struct LDKHTLCUpdate *NONNULL_PTR a, const struct LDKHTLCUpdate *NONNULL_PTR b);
28873 export function HTLCUpdate_eq(a: bigint, b: bigint): boolean {
28874 if(!isWasmInitialized) {
28875 throw new Error("initializeWasm() must be awaited first!");
28877 const nativeResponseValue = wasm.TS_HTLCUpdate_eq(a, b);
28878 return nativeResponseValue;
28880 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
28882 export function HTLCUpdate_write(obj: bigint): number {
28883 if(!isWasmInitialized) {
28884 throw new Error("initializeWasm() must be awaited first!");
28886 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
28887 return nativeResponseValue;
28889 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
28891 export function HTLCUpdate_read(ser: number): bigint {
28892 if(!isWasmInitialized) {
28893 throw new Error("initializeWasm() must be awaited first!");
28895 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
28896 return nativeResponseValue;
28898 // void Balance_free(struct LDKBalance this_ptr);
28900 export function Balance_free(this_ptr: bigint): void {
28901 if(!isWasmInitialized) {
28902 throw new Error("initializeWasm() must be awaited first!");
28904 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
28905 // debug statements here
28907 // uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
28909 export function Balance_clone_ptr(arg: bigint): bigint {
28910 if(!isWasmInitialized) {
28911 throw new Error("initializeWasm() must be awaited first!");
28913 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
28914 return nativeResponseValue;
28916 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
28918 export function Balance_clone(orig: bigint): bigint {
28919 if(!isWasmInitialized) {
28920 throw new Error("initializeWasm() must be awaited first!");
28922 const nativeResponseValue = wasm.TS_Balance_clone(orig);
28923 return nativeResponseValue;
28925 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t amount_satoshis);
28927 export function Balance_claimable_on_channel_close(amount_satoshis: bigint): bigint {
28928 if(!isWasmInitialized) {
28929 throw new Error("initializeWasm() must be awaited first!");
28931 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(amount_satoshis);
28932 return nativeResponseValue;
28934 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t amount_satoshis, uint32_t confirmation_height);
28936 export function Balance_claimable_awaiting_confirmations(amount_satoshis: bigint, confirmation_height: number): bigint {
28937 if(!isWasmInitialized) {
28938 throw new Error("initializeWasm() must be awaited first!");
28940 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(amount_satoshis, confirmation_height);
28941 return nativeResponseValue;
28943 // struct LDKBalance Balance_contentious_claimable(uint64_t amount_satoshis, uint32_t timeout_height, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_preimage);
28945 export function Balance_contentious_claimable(amount_satoshis: bigint, timeout_height: number, payment_hash: number, payment_preimage: number): bigint {
28946 if(!isWasmInitialized) {
28947 throw new Error("initializeWasm() must be awaited first!");
28949 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(amount_satoshis, timeout_height, payment_hash, payment_preimage);
28950 return nativeResponseValue;
28952 // struct LDKBalance Balance_maybe_timeout_claimable_htlc(uint64_t amount_satoshis, uint32_t claimable_height, struct LDKThirtyTwoBytes payment_hash);
28954 export function Balance_maybe_timeout_claimable_htlc(amount_satoshis: bigint, claimable_height: number, payment_hash: number): bigint {
28955 if(!isWasmInitialized) {
28956 throw new Error("initializeWasm() must be awaited first!");
28958 const nativeResponseValue = wasm.TS_Balance_maybe_timeout_claimable_htlc(amount_satoshis, claimable_height, payment_hash);
28959 return nativeResponseValue;
28961 // struct LDKBalance Balance_maybe_preimage_claimable_htlc(uint64_t amount_satoshis, uint32_t expiry_height, struct LDKThirtyTwoBytes payment_hash);
28963 export function Balance_maybe_preimage_claimable_htlc(amount_satoshis: bigint, expiry_height: number, payment_hash: number): bigint {
28964 if(!isWasmInitialized) {
28965 throw new Error("initializeWasm() must be awaited first!");
28967 const nativeResponseValue = wasm.TS_Balance_maybe_preimage_claimable_htlc(amount_satoshis, expiry_height, payment_hash);
28968 return nativeResponseValue;
28970 // struct LDKBalance Balance_counterparty_revoked_output_claimable(uint64_t amount_satoshis);
28972 export function Balance_counterparty_revoked_output_claimable(amount_satoshis: bigint): bigint {
28973 if(!isWasmInitialized) {
28974 throw new Error("initializeWasm() must be awaited first!");
28976 const nativeResponseValue = wasm.TS_Balance_counterparty_revoked_output_claimable(amount_satoshis);
28977 return nativeResponseValue;
28979 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
28981 export function Balance_eq(a: bigint, b: bigint): boolean {
28982 if(!isWasmInitialized) {
28983 throw new Error("initializeWasm() must be awaited first!");
28985 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
28986 return nativeResponseValue;
28988 // MUST_USE_RES uint64_t Balance_claimable_amount_satoshis(const struct LDKBalance *NONNULL_PTR this_arg);
28990 export function Balance_claimable_amount_satoshis(this_arg: bigint): bigint {
28991 if(!isWasmInitialized) {
28992 throw new Error("initializeWasm() must be awaited first!");
28994 const nativeResponseValue = wasm.TS_Balance_claimable_amount_satoshis(this_arg);
28995 return nativeResponseValue;
28997 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
28999 export function ChannelMonitor_free(this_obj: bigint): void {
29000 if(!isWasmInitialized) {
29001 throw new Error("initializeWasm() must be awaited first!");
29003 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
29004 // debug statements here
29006 // uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
29008 export function ChannelMonitor_clone_ptr(arg: bigint): bigint {
29009 if(!isWasmInitialized) {
29010 throw new Error("initializeWasm() must be awaited first!");
29012 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
29013 return nativeResponseValue;
29015 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
29017 export function ChannelMonitor_clone(orig: bigint): bigint {
29018 if(!isWasmInitialized) {
29019 throw new Error("initializeWasm() must be awaited first!");
29021 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
29022 return nativeResponseValue;
29024 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
29026 export function ChannelMonitor_write(obj: bigint): number {
29027 if(!isWasmInitialized) {
29028 throw new Error("initializeWasm() must be awaited first!");
29030 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
29031 return nativeResponseValue;
29033 // 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);
29035 export function ChannelMonitor_update_monitor(this_arg: bigint, updates: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): bigint {
29036 if(!isWasmInitialized) {
29037 throw new Error("initializeWasm() must be awaited first!");
29039 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
29040 return nativeResponseValue;
29042 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
29044 export function ChannelMonitor_get_latest_update_id(this_arg: bigint): bigint {
29045 if(!isWasmInitialized) {
29046 throw new Error("initializeWasm() must be awaited first!");
29048 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
29049 return nativeResponseValue;
29051 // MUST_USE_RES struct LDKC2Tuple_OutPointCVec_u8ZZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
29053 export function ChannelMonitor_get_funding_txo(this_arg: bigint): bigint {
29054 if(!isWasmInitialized) {
29055 throw new Error("initializeWasm() must be awaited first!");
29057 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
29058 return nativeResponseValue;
29060 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
29062 export function ChannelMonitor_get_outputs_to_watch(this_arg: bigint): number {
29063 if(!isWasmInitialized) {
29064 throw new Error("initializeWasm() must be awaited first!");
29066 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
29067 return nativeResponseValue;
29069 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter, const struct LDKLogger *NONNULL_PTR logger);
29071 export function ChannelMonitor_load_outputs_to_watch(this_arg: bigint, filter: bigint, logger: bigint): void {
29072 if(!isWasmInitialized) {
29073 throw new Error("initializeWasm() must be awaited first!");
29075 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter, logger);
29076 // debug statements here
29078 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
29080 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: bigint): number {
29081 if(!isWasmInitialized) {
29082 throw new Error("initializeWasm() must be awaited first!");
29084 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
29085 return nativeResponseValue;
29087 // void ChannelMonitor_process_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKEventHandler *NONNULL_PTR handler);
29089 export function ChannelMonitor_process_pending_events(this_arg: bigint, handler: bigint): void {
29090 if(!isWasmInitialized) {
29091 throw new Error("initializeWasm() must be awaited first!");
29093 const nativeResponseValue = wasm.TS_ChannelMonitor_process_pending_events(this_arg, handler);
29094 // debug statements here
29096 // MUST_USE_RES struct LDKCommitmentTransaction ChannelMonitor_initial_counterparty_commitment_tx(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
29098 export function ChannelMonitor_initial_counterparty_commitment_tx(this_arg: bigint): bigint {
29099 if(!isWasmInitialized) {
29100 throw new Error("initializeWasm() must be awaited first!");
29102 const nativeResponseValue = wasm.TS_ChannelMonitor_initial_counterparty_commitment_tx(this_arg);
29103 return nativeResponseValue;
29105 // 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);
29107 export function ChannelMonitor_counterparty_commitment_txs_from_update(this_arg: bigint, update: bigint): number {
29108 if(!isWasmInitialized) {
29109 throw new Error("initializeWasm() must be awaited first!");
29111 const nativeResponseValue = wasm.TS_ChannelMonitor_counterparty_commitment_txs_from_update(this_arg, update);
29112 return nativeResponseValue;
29114 // 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);
29116 export function ChannelMonitor_sign_to_local_justice_tx(this_arg: bigint, justice_tx: number, input_idx: number, value: bigint, commitment_number: bigint): bigint {
29117 if(!isWasmInitialized) {
29118 throw new Error("initializeWasm() must be awaited first!");
29120 const nativeResponseValue = wasm.TS_ChannelMonitor_sign_to_local_justice_tx(this_arg, justice_tx, input_idx, value, commitment_number);
29121 return nativeResponseValue;
29123 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
29125 export function ChannelMonitor_get_counterparty_node_id(this_arg: bigint): number {
29126 if(!isWasmInitialized) {
29127 throw new Error("initializeWasm() must be awaited first!");
29129 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
29130 return nativeResponseValue;
29132 // 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);
29134 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: bigint, logger: bigint): number {
29135 if(!isWasmInitialized) {
29136 throw new Error("initializeWasm() must be awaited first!");
29138 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
29139 return nativeResponseValue;
29141 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
29143 export function ChannelMonitor_block_connected(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
29144 if(!isWasmInitialized) {
29145 throw new Error("initializeWasm() must be awaited first!");
29147 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
29148 return nativeResponseValue;
29150 // void ChannelMonitor_block_disconnected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
29152 export function ChannelMonitor_block_disconnected(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
29153 if(!isWasmInitialized) {
29154 throw new Error("initializeWasm() must be awaited first!");
29156 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
29157 // debug statements here
29159 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_transactions_confirmed(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
29161 export function ChannelMonitor_transactions_confirmed(this_arg: bigint, header: number, txdata: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
29162 if(!isWasmInitialized) {
29163 throw new Error("initializeWasm() must be awaited first!");
29165 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
29166 return nativeResponseValue;
29168 // void ChannelMonitor_transaction_unconfirmed(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
29170 export function ChannelMonitor_transaction_unconfirmed(this_arg: bigint, txid: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
29171 if(!isWasmInitialized) {
29172 throw new Error("initializeWasm() must be awaited first!");
29174 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
29175 // debug statements here
29177 // MUST_USE_RES struct LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_best_block_updated(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
29179 export function ChannelMonitor_best_block_updated(this_arg: bigint, header: number, height: number, broadcaster: bigint, fee_estimator: bigint, logger: bigint): number {
29180 if(!isWasmInitialized) {
29181 throw new Error("initializeWasm() must be awaited first!");
29183 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
29184 return nativeResponseValue;
29186 // MUST_USE_RES struct LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
29188 export function ChannelMonitor_get_relevant_txids(this_arg: bigint): number {
29189 if(!isWasmInitialized) {
29190 throw new Error("initializeWasm() must be awaited first!");
29192 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
29193 return nativeResponseValue;
29195 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
29197 export function ChannelMonitor_current_best_block(this_arg: bigint): bigint {
29198 if(!isWasmInitialized) {
29199 throw new Error("initializeWasm() must be awaited first!");
29201 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
29202 return nativeResponseValue;
29204 // void ChannelMonitor_rebroadcast_pending_claims(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
29206 export function ChannelMonitor_rebroadcast_pending_claims(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, logger: bigint): void {
29207 if(!isWasmInitialized) {
29208 throw new Error("initializeWasm() must be awaited first!");
29210 const nativeResponseValue = wasm.TS_ChannelMonitor_rebroadcast_pending_claims(this_arg, broadcaster, fee_estimator, logger);
29211 // debug statements here
29213 // MUST_USE_RES struct LDKCVec_SpendableOutputDescriptorZ ChannelMonitor_get_spendable_outputs(const struct LDKChannelMonitor *NONNULL_PTR this_arg, struct LDKTransaction tx, uint32_t confirmation_height);
29215 export function ChannelMonitor_get_spendable_outputs(this_arg: bigint, tx: number, confirmation_height: number): number {
29216 if(!isWasmInitialized) {
29217 throw new Error("initializeWasm() must be awaited first!");
29219 const nativeResponseValue = wasm.TS_ChannelMonitor_get_spendable_outputs(this_arg, tx, confirmation_height);
29220 return nativeResponseValue;
29222 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
29224 export function ChannelMonitor_get_claimable_balances(this_arg: bigint): number {
29225 if(!isWasmInitialized) {
29226 throw new Error("initializeWasm() must be awaited first!");
29228 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
29229 return nativeResponseValue;
29231 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKEntropySource *NONNULL_PTR arg_a, const struct LDKSignerProvider *NONNULL_PTR arg_b);
29233 export function C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(ser: number, arg_a: bigint, arg_b: bigint): bigint {
29234 if(!isWasmInitialized) {
29235 throw new Error("initializeWasm() must be awaited first!");
29237 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(ser, arg_a, arg_b);
29238 return nativeResponseValue;
29240 // void OutPoint_free(struct LDKOutPoint this_obj);
29242 export function OutPoint_free(this_obj: bigint): void {
29243 if(!isWasmInitialized) {
29244 throw new Error("initializeWasm() must be awaited first!");
29246 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
29247 // debug statements here
29249 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
29251 export function OutPoint_get_txid(this_ptr: bigint): number {
29252 if(!isWasmInitialized) {
29253 throw new Error("initializeWasm() must be awaited first!");
29255 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
29256 return nativeResponseValue;
29258 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29260 export function OutPoint_set_txid(this_ptr: bigint, val: number): void {
29261 if(!isWasmInitialized) {
29262 throw new Error("initializeWasm() must be awaited first!");
29264 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
29265 // debug statements here
29267 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
29269 export function OutPoint_get_index(this_ptr: bigint): number {
29270 if(!isWasmInitialized) {
29271 throw new Error("initializeWasm() must be awaited first!");
29273 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
29274 return nativeResponseValue;
29276 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
29278 export function OutPoint_set_index(this_ptr: bigint, val: number): void {
29279 if(!isWasmInitialized) {
29280 throw new Error("initializeWasm() must be awaited first!");
29282 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
29283 // debug statements here
29285 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
29287 export function OutPoint_new(txid_arg: number, index_arg: number): bigint {
29288 if(!isWasmInitialized) {
29289 throw new Error("initializeWasm() must be awaited first!");
29291 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
29292 return nativeResponseValue;
29294 // uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
29296 export function OutPoint_clone_ptr(arg: bigint): bigint {
29297 if(!isWasmInitialized) {
29298 throw new Error("initializeWasm() must be awaited first!");
29300 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
29301 return nativeResponseValue;
29303 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
29305 export function OutPoint_clone(orig: bigint): bigint {
29306 if(!isWasmInitialized) {
29307 throw new Error("initializeWasm() must be awaited first!");
29309 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
29310 return nativeResponseValue;
29312 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
29314 export function OutPoint_eq(a: bigint, b: bigint): boolean {
29315 if(!isWasmInitialized) {
29316 throw new Error("initializeWasm() must be awaited first!");
29318 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
29319 return nativeResponseValue;
29321 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
29323 export function OutPoint_hash(o: bigint): bigint {
29324 if(!isWasmInitialized) {
29325 throw new Error("initializeWasm() must be awaited first!");
29327 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
29328 return nativeResponseValue;
29330 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
29332 export function OutPoint_to_channel_id(this_arg: bigint): number {
29333 if(!isWasmInitialized) {
29334 throw new Error("initializeWasm() must be awaited first!");
29336 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
29337 return nativeResponseValue;
29339 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
29341 export function OutPoint_write(obj: bigint): number {
29342 if(!isWasmInitialized) {
29343 throw new Error("initializeWasm() must be awaited first!");
29345 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
29346 return nativeResponseValue;
29348 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
29350 export function OutPoint_read(ser: number): bigint {
29351 if(!isWasmInitialized) {
29352 throw new Error("initializeWasm() must be awaited first!");
29354 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
29355 return nativeResponseValue;
29357 // void InboundHTLCErr_free(struct LDKInboundHTLCErr this_obj);
29359 export function InboundHTLCErr_free(this_obj: bigint): void {
29360 if(!isWasmInitialized) {
29361 throw new Error("initializeWasm() must be awaited first!");
29363 const nativeResponseValue = wasm.TS_InboundHTLCErr_free(this_obj);
29364 // debug statements here
29366 // uint16_t InboundHTLCErr_get_err_code(const struct LDKInboundHTLCErr *NONNULL_PTR this_ptr);
29368 export function InboundHTLCErr_get_err_code(this_ptr: bigint): number {
29369 if(!isWasmInitialized) {
29370 throw new Error("initializeWasm() must be awaited first!");
29372 const nativeResponseValue = wasm.TS_InboundHTLCErr_get_err_code(this_ptr);
29373 return nativeResponseValue;
29375 // void InboundHTLCErr_set_err_code(struct LDKInboundHTLCErr *NONNULL_PTR this_ptr, uint16_t val);
29377 export function InboundHTLCErr_set_err_code(this_ptr: bigint, val: number): void {
29378 if(!isWasmInitialized) {
29379 throw new Error("initializeWasm() must be awaited first!");
29381 const nativeResponseValue = wasm.TS_InboundHTLCErr_set_err_code(this_ptr, val);
29382 // debug statements here
29384 // struct LDKCVec_u8Z InboundHTLCErr_get_err_data(const struct LDKInboundHTLCErr *NONNULL_PTR this_ptr);
29386 export function InboundHTLCErr_get_err_data(this_ptr: bigint): number {
29387 if(!isWasmInitialized) {
29388 throw new Error("initializeWasm() must be awaited first!");
29390 const nativeResponseValue = wasm.TS_InboundHTLCErr_get_err_data(this_ptr);
29391 return nativeResponseValue;
29393 // void InboundHTLCErr_set_err_data(struct LDKInboundHTLCErr *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
29395 export function InboundHTLCErr_set_err_data(this_ptr: bigint, val: number): void {
29396 if(!isWasmInitialized) {
29397 throw new Error("initializeWasm() must be awaited first!");
29399 const nativeResponseValue = wasm.TS_InboundHTLCErr_set_err_data(this_ptr, val);
29400 // debug statements here
29402 // struct LDKStr InboundHTLCErr_get_msg(const struct LDKInboundHTLCErr *NONNULL_PTR this_ptr);
29404 export function InboundHTLCErr_get_msg(this_ptr: bigint): number {
29405 if(!isWasmInitialized) {
29406 throw new Error("initializeWasm() must be awaited first!");
29408 const nativeResponseValue = wasm.TS_InboundHTLCErr_get_msg(this_ptr);
29409 return nativeResponseValue;
29411 // void InboundHTLCErr_set_msg(struct LDKInboundHTLCErr *NONNULL_PTR this_ptr, struct LDKStr val);
29413 export function InboundHTLCErr_set_msg(this_ptr: bigint, val: number): void {
29414 if(!isWasmInitialized) {
29415 throw new Error("initializeWasm() must be awaited first!");
29417 const nativeResponseValue = wasm.TS_InboundHTLCErr_set_msg(this_ptr, val);
29418 // debug statements here
29420 // MUST_USE_RES struct LDKInboundHTLCErr InboundHTLCErr_new(uint16_t err_code_arg, struct LDKCVec_u8Z err_data_arg, struct LDKStr msg_arg);
29422 export function InboundHTLCErr_new(err_code_arg: number, err_data_arg: number, msg_arg: number): bigint {
29423 if(!isWasmInitialized) {
29424 throw new Error("initializeWasm() must be awaited first!");
29426 const nativeResponseValue = wasm.TS_InboundHTLCErr_new(err_code_arg, err_data_arg, msg_arg);
29427 return nativeResponseValue;
29429 // struct LDKCResult_PendingHTLCInfoInboundHTLCErrZ peel_payment_onion(const struct LDKUpdateAddHTLC *NONNULL_PTR msg, const struct LDKNodeSigner *NONNULL_PTR node_signer, const struct LDKLogger *NONNULL_PTR logger, uint32_t cur_height, bool accept_mpp_keysend, bool allow_skimmed_fees);
29431 export function peel_payment_onion(msg: bigint, node_signer: bigint, logger: bigint, cur_height: number, accept_mpp_keysend: boolean, allow_skimmed_fees: boolean): bigint {
29432 if(!isWasmInitialized) {
29433 throw new Error("initializeWasm() must be awaited first!");
29435 const nativeResponseValue = wasm.TS_peel_payment_onion(msg, node_signer, logger, cur_height, accept_mpp_keysend, allow_skimmed_fees);
29436 return nativeResponseValue;
29438 // void PendingHTLCRouting_free(struct LDKPendingHTLCRouting this_ptr);
29440 export function PendingHTLCRouting_free(this_ptr: bigint): void {
29441 if(!isWasmInitialized) {
29442 throw new Error("initializeWasm() must be awaited first!");
29444 const nativeResponseValue = wasm.TS_PendingHTLCRouting_free(this_ptr);
29445 // debug statements here
29447 // uint64_t PendingHTLCRouting_clone_ptr(LDKPendingHTLCRouting *NONNULL_PTR arg);
29449 export function PendingHTLCRouting_clone_ptr(arg: bigint): bigint {
29450 if(!isWasmInitialized) {
29451 throw new Error("initializeWasm() must be awaited first!");
29453 const nativeResponseValue = wasm.TS_PendingHTLCRouting_clone_ptr(arg);
29454 return nativeResponseValue;
29456 // struct LDKPendingHTLCRouting PendingHTLCRouting_clone(const struct LDKPendingHTLCRouting *NONNULL_PTR orig);
29458 export function PendingHTLCRouting_clone(orig: bigint): bigint {
29459 if(!isWasmInitialized) {
29460 throw new Error("initializeWasm() must be awaited first!");
29462 const nativeResponseValue = wasm.TS_PendingHTLCRouting_clone(orig);
29463 return nativeResponseValue;
29465 // struct LDKPendingHTLCRouting PendingHTLCRouting_forward(struct LDKOnionPacket onion_packet, uint64_t short_channel_id, struct LDKBlindedForward blinded);
29467 export function PendingHTLCRouting_forward(onion_packet: bigint, short_channel_id: bigint, blinded: bigint): bigint {
29468 if(!isWasmInitialized) {
29469 throw new Error("initializeWasm() must be awaited first!");
29471 const nativeResponseValue = wasm.TS_PendingHTLCRouting_forward(onion_packet, short_channel_id, blinded);
29472 return nativeResponseValue;
29474 // struct LDKPendingHTLCRouting PendingHTLCRouting_receive(struct LDKFinalOnionHopData payment_data, struct LDKCOption_CVec_u8ZZ payment_metadata, uint32_t incoming_cltv_expiry, struct LDKThirtyTwoBytes phantom_shared_secret, struct LDKCVec_C2Tuple_u64CVec_u8ZZZ custom_tlvs, bool requires_blinded_error);
29476 export function PendingHTLCRouting_receive(payment_data: bigint, payment_metadata: bigint, incoming_cltv_expiry: number, phantom_shared_secret: number, custom_tlvs: number, requires_blinded_error: boolean): bigint {
29477 if(!isWasmInitialized) {
29478 throw new Error("initializeWasm() must be awaited first!");
29480 const nativeResponseValue = wasm.TS_PendingHTLCRouting_receive(payment_data, payment_metadata, incoming_cltv_expiry, phantom_shared_secret, custom_tlvs, requires_blinded_error);
29481 return nativeResponseValue;
29483 // struct LDKPendingHTLCRouting PendingHTLCRouting_receive_keysend(struct LDKFinalOnionHopData payment_data, struct LDKThirtyTwoBytes payment_preimage, struct LDKCOption_CVec_u8ZZ payment_metadata, uint32_t incoming_cltv_expiry, struct LDKCVec_C2Tuple_u64CVec_u8ZZZ custom_tlvs);
29485 export function PendingHTLCRouting_receive_keysend(payment_data: bigint, payment_preimage: number, payment_metadata: bigint, incoming_cltv_expiry: number, custom_tlvs: number): bigint {
29486 if(!isWasmInitialized) {
29487 throw new Error("initializeWasm() must be awaited first!");
29489 const nativeResponseValue = wasm.TS_PendingHTLCRouting_receive_keysend(payment_data, payment_preimage, payment_metadata, incoming_cltv_expiry, custom_tlvs);
29490 return nativeResponseValue;
29492 // void BlindedForward_free(struct LDKBlindedForward this_obj);
29494 export function BlindedForward_free(this_obj: bigint): void {
29495 if(!isWasmInitialized) {
29496 throw new Error("initializeWasm() must be awaited first!");
29498 const nativeResponseValue = wasm.TS_BlindedForward_free(this_obj);
29499 // debug statements here
29501 // struct LDKPublicKey BlindedForward_get_inbound_blinding_point(const struct LDKBlindedForward *NONNULL_PTR this_ptr);
29503 export function BlindedForward_get_inbound_blinding_point(this_ptr: bigint): number {
29504 if(!isWasmInitialized) {
29505 throw new Error("initializeWasm() must be awaited first!");
29507 const nativeResponseValue = wasm.TS_BlindedForward_get_inbound_blinding_point(this_ptr);
29508 return nativeResponseValue;
29510 // void BlindedForward_set_inbound_blinding_point(struct LDKBlindedForward *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29512 export function BlindedForward_set_inbound_blinding_point(this_ptr: bigint, val: number): void {
29513 if(!isWasmInitialized) {
29514 throw new Error("initializeWasm() must be awaited first!");
29516 const nativeResponseValue = wasm.TS_BlindedForward_set_inbound_blinding_point(this_ptr, val);
29517 // debug statements here
29519 // enum LDKBlindedFailure BlindedForward_get_failure(const struct LDKBlindedForward *NONNULL_PTR this_ptr);
29521 export function BlindedForward_get_failure(this_ptr: bigint): BlindedFailure {
29522 if(!isWasmInitialized) {
29523 throw new Error("initializeWasm() must be awaited first!");
29525 const nativeResponseValue = wasm.TS_BlindedForward_get_failure(this_ptr);
29526 return nativeResponseValue;
29528 // void BlindedForward_set_failure(struct LDKBlindedForward *NONNULL_PTR this_ptr, enum LDKBlindedFailure val);
29530 export function BlindedForward_set_failure(this_ptr: bigint, val: BlindedFailure): void {
29531 if(!isWasmInitialized) {
29532 throw new Error("initializeWasm() must be awaited first!");
29534 const nativeResponseValue = wasm.TS_BlindedForward_set_failure(this_ptr, val);
29535 // debug statements here
29537 // MUST_USE_RES struct LDKBlindedForward BlindedForward_new(struct LDKPublicKey inbound_blinding_point_arg, enum LDKBlindedFailure failure_arg);
29539 export function BlindedForward_new(inbound_blinding_point_arg: number, failure_arg: BlindedFailure): bigint {
29540 if(!isWasmInitialized) {
29541 throw new Error("initializeWasm() must be awaited first!");
29543 const nativeResponseValue = wasm.TS_BlindedForward_new(inbound_blinding_point_arg, failure_arg);
29544 return nativeResponseValue;
29546 // uint64_t BlindedForward_clone_ptr(LDKBlindedForward *NONNULL_PTR arg);
29548 export function BlindedForward_clone_ptr(arg: bigint): bigint {
29549 if(!isWasmInitialized) {
29550 throw new Error("initializeWasm() must be awaited first!");
29552 const nativeResponseValue = wasm.TS_BlindedForward_clone_ptr(arg);
29553 return nativeResponseValue;
29555 // struct LDKBlindedForward BlindedForward_clone(const struct LDKBlindedForward *NONNULL_PTR orig);
29557 export function BlindedForward_clone(orig: bigint): bigint {
29558 if(!isWasmInitialized) {
29559 throw new Error("initializeWasm() must be awaited first!");
29561 const nativeResponseValue = wasm.TS_BlindedForward_clone(orig);
29562 return nativeResponseValue;
29564 // uint64_t BlindedForward_hash(const struct LDKBlindedForward *NONNULL_PTR o);
29566 export function BlindedForward_hash(o: bigint): bigint {
29567 if(!isWasmInitialized) {
29568 throw new Error("initializeWasm() must be awaited first!");
29570 const nativeResponseValue = wasm.TS_BlindedForward_hash(o);
29571 return nativeResponseValue;
29573 // bool BlindedForward_eq(const struct LDKBlindedForward *NONNULL_PTR a, const struct LDKBlindedForward *NONNULL_PTR b);
29575 export function BlindedForward_eq(a: bigint, b: bigint): boolean {
29576 if(!isWasmInitialized) {
29577 throw new Error("initializeWasm() must be awaited first!");
29579 const nativeResponseValue = wasm.TS_BlindedForward_eq(a, b);
29580 return nativeResponseValue;
29582 // void PendingHTLCInfo_free(struct LDKPendingHTLCInfo this_obj);
29584 export function PendingHTLCInfo_free(this_obj: bigint): void {
29585 if(!isWasmInitialized) {
29586 throw new Error("initializeWasm() must be awaited first!");
29588 const nativeResponseValue = wasm.TS_PendingHTLCInfo_free(this_obj);
29589 // debug statements here
29591 // struct LDKPendingHTLCRouting PendingHTLCInfo_get_routing(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr);
29593 export function PendingHTLCInfo_get_routing(this_ptr: bigint): bigint {
29594 if(!isWasmInitialized) {
29595 throw new Error("initializeWasm() must be awaited first!");
29597 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_routing(this_ptr);
29598 return nativeResponseValue;
29600 // void PendingHTLCInfo_set_routing(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, struct LDKPendingHTLCRouting val);
29602 export function PendingHTLCInfo_set_routing(this_ptr: bigint, val: bigint): void {
29603 if(!isWasmInitialized) {
29604 throw new Error("initializeWasm() must be awaited first!");
29606 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_routing(this_ptr, val);
29607 // debug statements here
29609 // const uint8_t (*PendingHTLCInfo_get_incoming_shared_secret(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr))[32];
29611 export function PendingHTLCInfo_get_incoming_shared_secret(this_ptr: bigint): number {
29612 if(!isWasmInitialized) {
29613 throw new Error("initializeWasm() must be awaited first!");
29615 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_incoming_shared_secret(this_ptr);
29616 return nativeResponseValue;
29618 // void PendingHTLCInfo_set_incoming_shared_secret(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29620 export function PendingHTLCInfo_set_incoming_shared_secret(this_ptr: bigint, val: number): void {
29621 if(!isWasmInitialized) {
29622 throw new Error("initializeWasm() must be awaited first!");
29624 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_incoming_shared_secret(this_ptr, val);
29625 // debug statements here
29627 // const uint8_t (*PendingHTLCInfo_get_payment_hash(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr))[32];
29629 export function PendingHTLCInfo_get_payment_hash(this_ptr: bigint): number {
29630 if(!isWasmInitialized) {
29631 throw new Error("initializeWasm() must be awaited first!");
29633 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_payment_hash(this_ptr);
29634 return nativeResponseValue;
29636 // void PendingHTLCInfo_set_payment_hash(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29638 export function PendingHTLCInfo_set_payment_hash(this_ptr: bigint, val: number): void {
29639 if(!isWasmInitialized) {
29640 throw new Error("initializeWasm() must be awaited first!");
29642 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_payment_hash(this_ptr, val);
29643 // debug statements here
29645 // struct LDKCOption_u64Z PendingHTLCInfo_get_incoming_amt_msat(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr);
29647 export function PendingHTLCInfo_get_incoming_amt_msat(this_ptr: bigint): bigint {
29648 if(!isWasmInitialized) {
29649 throw new Error("initializeWasm() must be awaited first!");
29651 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_incoming_amt_msat(this_ptr);
29652 return nativeResponseValue;
29654 // void PendingHTLCInfo_set_incoming_amt_msat(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
29656 export function PendingHTLCInfo_set_incoming_amt_msat(this_ptr: bigint, val: bigint): void {
29657 if(!isWasmInitialized) {
29658 throw new Error("initializeWasm() must be awaited first!");
29660 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_incoming_amt_msat(this_ptr, val);
29661 // debug statements here
29663 // uint64_t PendingHTLCInfo_get_outgoing_amt_msat(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr);
29665 export function PendingHTLCInfo_get_outgoing_amt_msat(this_ptr: bigint): bigint {
29666 if(!isWasmInitialized) {
29667 throw new Error("initializeWasm() must be awaited first!");
29669 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_outgoing_amt_msat(this_ptr);
29670 return nativeResponseValue;
29672 // void PendingHTLCInfo_set_outgoing_amt_msat(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, uint64_t val);
29674 export function PendingHTLCInfo_set_outgoing_amt_msat(this_ptr: bigint, val: bigint): void {
29675 if(!isWasmInitialized) {
29676 throw new Error("initializeWasm() must be awaited first!");
29678 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_outgoing_amt_msat(this_ptr, val);
29679 // debug statements here
29681 // uint32_t PendingHTLCInfo_get_outgoing_cltv_value(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr);
29683 export function PendingHTLCInfo_get_outgoing_cltv_value(this_ptr: bigint): number {
29684 if(!isWasmInitialized) {
29685 throw new Error("initializeWasm() must be awaited first!");
29687 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_outgoing_cltv_value(this_ptr);
29688 return nativeResponseValue;
29690 // void PendingHTLCInfo_set_outgoing_cltv_value(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, uint32_t val);
29692 export function PendingHTLCInfo_set_outgoing_cltv_value(this_ptr: bigint, val: number): void {
29693 if(!isWasmInitialized) {
29694 throw new Error("initializeWasm() must be awaited first!");
29696 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_outgoing_cltv_value(this_ptr, val);
29697 // debug statements here
29699 // struct LDKCOption_u64Z PendingHTLCInfo_get_skimmed_fee_msat(const struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr);
29701 export function PendingHTLCInfo_get_skimmed_fee_msat(this_ptr: bigint): bigint {
29702 if(!isWasmInitialized) {
29703 throw new Error("initializeWasm() must be awaited first!");
29705 const nativeResponseValue = wasm.TS_PendingHTLCInfo_get_skimmed_fee_msat(this_ptr);
29706 return nativeResponseValue;
29708 // void PendingHTLCInfo_set_skimmed_fee_msat(struct LDKPendingHTLCInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
29710 export function PendingHTLCInfo_set_skimmed_fee_msat(this_ptr: bigint, val: bigint): void {
29711 if(!isWasmInitialized) {
29712 throw new Error("initializeWasm() must be awaited first!");
29714 const nativeResponseValue = wasm.TS_PendingHTLCInfo_set_skimmed_fee_msat(this_ptr, val);
29715 // debug statements here
29717 // MUST_USE_RES struct LDKPendingHTLCInfo PendingHTLCInfo_new(struct LDKPendingHTLCRouting routing_arg, struct LDKThirtyTwoBytes incoming_shared_secret_arg, struct LDKThirtyTwoBytes payment_hash_arg, struct LDKCOption_u64Z incoming_amt_msat_arg, uint64_t outgoing_amt_msat_arg, uint32_t outgoing_cltv_value_arg, struct LDKCOption_u64Z skimmed_fee_msat_arg);
29719 export function PendingHTLCInfo_new(routing_arg: bigint, incoming_shared_secret_arg: number, payment_hash_arg: number, incoming_amt_msat_arg: bigint, outgoing_amt_msat_arg: bigint, outgoing_cltv_value_arg: number, skimmed_fee_msat_arg: bigint): bigint {
29720 if(!isWasmInitialized) {
29721 throw new Error("initializeWasm() must be awaited first!");
29723 const nativeResponseValue = wasm.TS_PendingHTLCInfo_new(routing_arg, incoming_shared_secret_arg, payment_hash_arg, incoming_amt_msat_arg, outgoing_amt_msat_arg, outgoing_cltv_value_arg, skimmed_fee_msat_arg);
29724 return nativeResponseValue;
29726 // uint64_t PendingHTLCInfo_clone_ptr(LDKPendingHTLCInfo *NONNULL_PTR arg);
29728 export function PendingHTLCInfo_clone_ptr(arg: bigint): bigint {
29729 if(!isWasmInitialized) {
29730 throw new Error("initializeWasm() must be awaited first!");
29732 const nativeResponseValue = wasm.TS_PendingHTLCInfo_clone_ptr(arg);
29733 return nativeResponseValue;
29735 // struct LDKPendingHTLCInfo PendingHTLCInfo_clone(const struct LDKPendingHTLCInfo *NONNULL_PTR orig);
29737 export function PendingHTLCInfo_clone(orig: bigint): bigint {
29738 if(!isWasmInitialized) {
29739 throw new Error("initializeWasm() must be awaited first!");
29741 const nativeResponseValue = wasm.TS_PendingHTLCInfo_clone(orig);
29742 return nativeResponseValue;
29744 // enum LDKBlindedFailure BlindedFailure_clone(const enum LDKBlindedFailure *NONNULL_PTR orig);
29746 export function BlindedFailure_clone(orig: bigint): BlindedFailure {
29747 if(!isWasmInitialized) {
29748 throw new Error("initializeWasm() must be awaited first!");
29750 const nativeResponseValue = wasm.TS_BlindedFailure_clone(orig);
29751 return nativeResponseValue;
29753 // enum LDKBlindedFailure BlindedFailure_from_introduction_node(void);
29755 export function BlindedFailure_from_introduction_node(): BlindedFailure {
29756 if(!isWasmInitialized) {
29757 throw new Error("initializeWasm() must be awaited first!");
29759 const nativeResponseValue = wasm.TS_BlindedFailure_from_introduction_node();
29760 return nativeResponseValue;
29762 // enum LDKBlindedFailure BlindedFailure_from_blinded_node(void);
29764 export function BlindedFailure_from_blinded_node(): BlindedFailure {
29765 if(!isWasmInitialized) {
29766 throw new Error("initializeWasm() must be awaited first!");
29768 const nativeResponseValue = wasm.TS_BlindedFailure_from_blinded_node();
29769 return nativeResponseValue;
29771 // uint64_t BlindedFailure_hash(const enum LDKBlindedFailure *NONNULL_PTR o);
29773 export function BlindedFailure_hash(o: bigint): bigint {
29774 if(!isWasmInitialized) {
29775 throw new Error("initializeWasm() must be awaited first!");
29777 const nativeResponseValue = wasm.TS_BlindedFailure_hash(o);
29778 return nativeResponseValue;
29780 // bool BlindedFailure_eq(const enum LDKBlindedFailure *NONNULL_PTR a, const enum LDKBlindedFailure *NONNULL_PTR b);
29782 export function BlindedFailure_eq(a: bigint, b: bigint): boolean {
29783 if(!isWasmInitialized) {
29784 throw new Error("initializeWasm() must be awaited first!");
29786 const nativeResponseValue = wasm.TS_BlindedFailure_eq(a, b);
29787 return nativeResponseValue;
29789 // void FailureCode_free(struct LDKFailureCode this_ptr);
29791 export function FailureCode_free(this_ptr: bigint): void {
29792 if(!isWasmInitialized) {
29793 throw new Error("initializeWasm() must be awaited first!");
29795 const nativeResponseValue = wasm.TS_FailureCode_free(this_ptr);
29796 // debug statements here
29798 // uint64_t FailureCode_clone_ptr(LDKFailureCode *NONNULL_PTR arg);
29800 export function FailureCode_clone_ptr(arg: bigint): bigint {
29801 if(!isWasmInitialized) {
29802 throw new Error("initializeWasm() must be awaited first!");
29804 const nativeResponseValue = wasm.TS_FailureCode_clone_ptr(arg);
29805 return nativeResponseValue;
29807 // struct LDKFailureCode FailureCode_clone(const struct LDKFailureCode *NONNULL_PTR orig);
29809 export function FailureCode_clone(orig: bigint): bigint {
29810 if(!isWasmInitialized) {
29811 throw new Error("initializeWasm() must be awaited first!");
29813 const nativeResponseValue = wasm.TS_FailureCode_clone(orig);
29814 return nativeResponseValue;
29816 // struct LDKFailureCode FailureCode_temporary_node_failure(void);
29818 export function FailureCode_temporary_node_failure(): bigint {
29819 if(!isWasmInitialized) {
29820 throw new Error("initializeWasm() must be awaited first!");
29822 const nativeResponseValue = wasm.TS_FailureCode_temporary_node_failure();
29823 return nativeResponseValue;
29825 // struct LDKFailureCode FailureCode_required_node_feature_missing(void);
29827 export function FailureCode_required_node_feature_missing(): bigint {
29828 if(!isWasmInitialized) {
29829 throw new Error("initializeWasm() must be awaited first!");
29831 const nativeResponseValue = wasm.TS_FailureCode_required_node_feature_missing();
29832 return nativeResponseValue;
29834 // struct LDKFailureCode FailureCode_incorrect_or_unknown_payment_details(void);
29836 export function FailureCode_incorrect_or_unknown_payment_details(): bigint {
29837 if(!isWasmInitialized) {
29838 throw new Error("initializeWasm() must be awaited first!");
29840 const nativeResponseValue = wasm.TS_FailureCode_incorrect_or_unknown_payment_details();
29841 return nativeResponseValue;
29843 // struct LDKFailureCode FailureCode_invalid_onion_payload(struct LDKCOption_C2Tuple_u64u16ZZ a);
29845 export function FailureCode_invalid_onion_payload(a: bigint): bigint {
29846 if(!isWasmInitialized) {
29847 throw new Error("initializeWasm() must be awaited first!");
29849 const nativeResponseValue = wasm.TS_FailureCode_invalid_onion_payload(a);
29850 return nativeResponseValue;
29852 // void ChannelManager_free(struct LDKChannelManager this_obj);
29854 export function ChannelManager_free(this_obj: bigint): void {
29855 if(!isWasmInitialized) {
29856 throw new Error("initializeWasm() must be awaited first!");
29858 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
29859 // debug statements here
29861 // void ChainParameters_free(struct LDKChainParameters this_obj);
29863 export function ChainParameters_free(this_obj: bigint): void {
29864 if(!isWasmInitialized) {
29865 throw new Error("initializeWasm() must be awaited first!");
29867 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
29868 // debug statements here
29870 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
29872 export function ChainParameters_get_network(this_ptr: bigint): Network {
29873 if(!isWasmInitialized) {
29874 throw new Error("initializeWasm() must be awaited first!");
29876 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
29877 return nativeResponseValue;
29879 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
29881 export function ChainParameters_set_network(this_ptr: bigint, val: Network): void {
29882 if(!isWasmInitialized) {
29883 throw new Error("initializeWasm() must be awaited first!");
29885 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
29886 // debug statements here
29888 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
29890 export function ChainParameters_get_best_block(this_ptr: bigint): bigint {
29891 if(!isWasmInitialized) {
29892 throw new Error("initializeWasm() must be awaited first!");
29894 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
29895 return nativeResponseValue;
29897 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
29899 export function ChainParameters_set_best_block(this_ptr: bigint, val: bigint): void {
29900 if(!isWasmInitialized) {
29901 throw new Error("initializeWasm() must be awaited first!");
29903 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
29904 // debug statements here
29906 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
29908 export function ChainParameters_new(network_arg: Network, best_block_arg: bigint): bigint {
29909 if(!isWasmInitialized) {
29910 throw new Error("initializeWasm() must be awaited first!");
29912 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
29913 return nativeResponseValue;
29915 // uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
29917 export function ChainParameters_clone_ptr(arg: bigint): bigint {
29918 if(!isWasmInitialized) {
29919 throw new Error("initializeWasm() must be awaited first!");
29921 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
29922 return nativeResponseValue;
29924 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
29926 export function ChainParameters_clone(orig: bigint): bigint {
29927 if(!isWasmInitialized) {
29928 throw new Error("initializeWasm() must be awaited first!");
29930 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
29931 return nativeResponseValue;
29933 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
29935 export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
29936 if(!isWasmInitialized) {
29937 throw new Error("initializeWasm() must be awaited first!");
29939 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
29940 // debug statements here
29942 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
29944 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
29945 if(!isWasmInitialized) {
29946 throw new Error("initializeWasm() must be awaited first!");
29948 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
29949 return nativeResponseValue;
29951 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
29953 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
29954 if(!isWasmInitialized) {
29955 throw new Error("initializeWasm() must be awaited first!");
29957 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
29958 // debug statements here
29960 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
29962 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
29963 if(!isWasmInitialized) {
29964 throw new Error("initializeWasm() must be awaited first!");
29966 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
29967 return nativeResponseValue;
29969 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
29971 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
29972 if(!isWasmInitialized) {
29973 throw new Error("initializeWasm() must be awaited first!");
29975 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
29976 // debug statements here
29978 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
29980 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
29981 if(!isWasmInitialized) {
29982 throw new Error("initializeWasm() must be awaited first!");
29984 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
29985 return nativeResponseValue;
29987 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
29989 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
29990 if(!isWasmInitialized) {
29991 throw new Error("initializeWasm() must be awaited first!");
29993 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
29994 // debug statements here
29996 // 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);
29998 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
29999 if(!isWasmInitialized) {
30000 throw new Error("initializeWasm() must be awaited first!");
30002 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
30003 return nativeResponseValue;
30005 // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
30007 export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
30008 if(!isWasmInitialized) {
30009 throw new Error("initializeWasm() must be awaited first!");
30011 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
30012 return nativeResponseValue;
30014 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
30016 export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
30017 if(!isWasmInitialized) {
30018 throw new Error("initializeWasm() must be awaited first!");
30020 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
30021 return nativeResponseValue;
30023 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
30025 export function ChannelCounterparty_free(this_obj: bigint): void {
30026 if(!isWasmInitialized) {
30027 throw new Error("initializeWasm() must be awaited first!");
30029 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
30030 // debug statements here
30032 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
30034 export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
30035 if(!isWasmInitialized) {
30036 throw new Error("initializeWasm() must be awaited first!");
30038 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
30039 return nativeResponseValue;
30041 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30043 export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
30044 if(!isWasmInitialized) {
30045 throw new Error("initializeWasm() must be awaited first!");
30047 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
30048 // debug statements here
30050 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
30052 export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
30053 if(!isWasmInitialized) {
30054 throw new Error("initializeWasm() must be awaited first!");
30056 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
30057 return nativeResponseValue;
30059 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
30061 export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
30062 if(!isWasmInitialized) {
30063 throw new Error("initializeWasm() must be awaited first!");
30065 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
30066 // debug statements here
30068 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
30070 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
30071 if(!isWasmInitialized) {
30072 throw new Error("initializeWasm() must be awaited first!");
30074 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
30075 return nativeResponseValue;
30077 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
30079 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
30080 if(!isWasmInitialized) {
30081 throw new Error("initializeWasm() must be awaited first!");
30083 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
30084 // debug statements here
30086 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
30088 export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
30089 if(!isWasmInitialized) {
30090 throw new Error("initializeWasm() must be awaited first!");
30092 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
30093 return nativeResponseValue;
30095 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
30097 export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
30098 if(!isWasmInitialized) {
30099 throw new Error("initializeWasm() must be awaited first!");
30101 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
30102 // debug statements here
30104 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
30106 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
30107 if(!isWasmInitialized) {
30108 throw new Error("initializeWasm() must be awaited first!");
30110 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
30111 return nativeResponseValue;
30113 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30115 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30116 if(!isWasmInitialized) {
30117 throw new Error("initializeWasm() must be awaited first!");
30119 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
30120 // debug statements here
30122 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
30124 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
30125 if(!isWasmInitialized) {
30126 throw new Error("initializeWasm() must be awaited first!");
30128 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
30129 return nativeResponseValue;
30131 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30133 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
30134 if(!isWasmInitialized) {
30135 throw new Error("initializeWasm() must be awaited first!");
30137 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
30138 // debug statements here
30140 // 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);
30142 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 {
30143 if(!isWasmInitialized) {
30144 throw new Error("initializeWasm() must be awaited first!");
30146 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);
30147 return nativeResponseValue;
30149 // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
30151 export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
30152 if(!isWasmInitialized) {
30153 throw new Error("initializeWasm() must be awaited first!");
30155 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
30156 return nativeResponseValue;
30158 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
30160 export function ChannelCounterparty_clone(orig: bigint): bigint {
30161 if(!isWasmInitialized) {
30162 throw new Error("initializeWasm() must be awaited first!");
30164 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
30165 return nativeResponseValue;
30167 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
30169 export function ChannelDetails_free(this_obj: bigint): void {
30170 if(!isWasmInitialized) {
30171 throw new Error("initializeWasm() must be awaited first!");
30173 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
30174 // debug statements here
30176 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
30178 export function ChannelDetails_get_channel_id(this_ptr: bigint): number {
30179 if(!isWasmInitialized) {
30180 throw new Error("initializeWasm() must be awaited first!");
30182 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
30183 return nativeResponseValue;
30185 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
30187 export function ChannelDetails_set_channel_id(this_ptr: bigint, val: number): void {
30188 if(!isWasmInitialized) {
30189 throw new Error("initializeWasm() must be awaited first!");
30191 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
30192 // debug statements here
30194 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30196 export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
30197 if(!isWasmInitialized) {
30198 throw new Error("initializeWasm() must be awaited first!");
30200 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
30201 return nativeResponseValue;
30203 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
30205 export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
30206 if(!isWasmInitialized) {
30207 throw new Error("initializeWasm() must be awaited first!");
30209 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
30210 // debug statements here
30212 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30214 export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
30215 if(!isWasmInitialized) {
30216 throw new Error("initializeWasm() must be awaited first!");
30218 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
30219 return nativeResponseValue;
30221 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
30223 export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
30224 if(!isWasmInitialized) {
30225 throw new Error("initializeWasm() must be awaited first!");
30227 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
30228 // debug statements here
30230 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30232 export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
30233 if(!isWasmInitialized) {
30234 throw new Error("initializeWasm() must be awaited first!");
30236 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
30237 return nativeResponseValue;
30239 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
30241 export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
30242 if(!isWasmInitialized) {
30243 throw new Error("initializeWasm() must be awaited first!");
30245 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
30246 // debug statements here
30248 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30250 export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
30251 if(!isWasmInitialized) {
30252 throw new Error("initializeWasm() must be awaited first!");
30254 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
30255 return nativeResponseValue;
30257 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30259 export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
30260 if(!isWasmInitialized) {
30261 throw new Error("initializeWasm() must be awaited first!");
30263 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
30264 // debug statements here
30266 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30268 export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
30269 if(!isWasmInitialized) {
30270 throw new Error("initializeWasm() must be awaited first!");
30272 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
30273 return nativeResponseValue;
30275 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30277 export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
30278 if(!isWasmInitialized) {
30279 throw new Error("initializeWasm() must be awaited first!");
30281 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
30282 // debug statements here
30284 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30286 export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
30287 if(!isWasmInitialized) {
30288 throw new Error("initializeWasm() must be awaited first!");
30290 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
30291 return nativeResponseValue;
30293 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30295 export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
30296 if(!isWasmInitialized) {
30297 throw new Error("initializeWasm() must be awaited first!");
30299 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
30300 // debug statements here
30302 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30304 export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
30305 if(!isWasmInitialized) {
30306 throw new Error("initializeWasm() must be awaited first!");
30308 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
30309 return nativeResponseValue;
30311 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
30313 export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
30314 if(!isWasmInitialized) {
30315 throw new Error("initializeWasm() must be awaited first!");
30317 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
30318 // debug statements here
30320 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30322 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
30323 if(!isWasmInitialized) {
30324 throw new Error("initializeWasm() must be awaited first!");
30326 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
30327 return nativeResponseValue;
30329 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30331 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
30332 if(!isWasmInitialized) {
30333 throw new Error("initializeWasm() must be awaited first!");
30335 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
30336 // debug statements here
30338 // struct LDKU128 ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30340 export function ChannelDetails_get_user_channel_id(this_ptr: bigint): number {
30341 if(!isWasmInitialized) {
30342 throw new Error("initializeWasm() must be awaited first!");
30344 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
30345 return nativeResponseValue;
30347 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKU128 val);
30349 export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: number): void {
30350 if(!isWasmInitialized) {
30351 throw new Error("initializeWasm() must be awaited first!");
30353 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
30354 // debug statements here
30356 // struct LDKCOption_u32Z ChannelDetails_get_feerate_sat_per_1000_weight(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30358 export function ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr: bigint): bigint {
30359 if(!isWasmInitialized) {
30360 throw new Error("initializeWasm() must be awaited first!");
30362 const nativeResponseValue = wasm.TS_ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr);
30363 return nativeResponseValue;
30365 // void ChannelDetails_set_feerate_sat_per_1000_weight(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
30367 export function ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: bigint): void {
30368 if(!isWasmInitialized) {
30369 throw new Error("initializeWasm() must be awaited first!");
30371 const nativeResponseValue = wasm.TS_ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr, val);
30372 // debug statements here
30374 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30376 export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
30377 if(!isWasmInitialized) {
30378 throw new Error("initializeWasm() must be awaited first!");
30380 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
30381 return nativeResponseValue;
30383 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
30385 export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
30386 if(!isWasmInitialized) {
30387 throw new Error("initializeWasm() must be awaited first!");
30389 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
30390 // debug statements here
30392 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30394 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
30395 if(!isWasmInitialized) {
30396 throw new Error("initializeWasm() must be awaited first!");
30398 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
30399 return nativeResponseValue;
30401 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
30403 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
30404 if(!isWasmInitialized) {
30405 throw new Error("initializeWasm() must be awaited first!");
30407 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
30408 // debug statements here
30410 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30412 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
30413 if(!isWasmInitialized) {
30414 throw new Error("initializeWasm() must be awaited first!");
30416 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
30417 return nativeResponseValue;
30419 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
30421 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
30422 if(!isWasmInitialized) {
30423 throw new Error("initializeWasm() must be awaited first!");
30425 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
30426 // debug statements here
30428 // uint64_t ChannelDetails_get_next_outbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30430 export function ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
30431 if(!isWasmInitialized) {
30432 throw new Error("initializeWasm() must be awaited first!");
30434 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr);
30435 return nativeResponseValue;
30437 // void ChannelDetails_set_next_outbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
30439 export function ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30440 if(!isWasmInitialized) {
30441 throw new Error("initializeWasm() must be awaited first!");
30443 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr, val);
30444 // debug statements here
30446 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30448 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
30449 if(!isWasmInitialized) {
30450 throw new Error("initializeWasm() must be awaited first!");
30452 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
30453 return nativeResponseValue;
30455 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
30457 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
30458 if(!isWasmInitialized) {
30459 throw new Error("initializeWasm() must be awaited first!");
30461 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
30462 // debug statements here
30464 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30466 export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
30467 if(!isWasmInitialized) {
30468 throw new Error("initializeWasm() must be awaited first!");
30470 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
30471 return nativeResponseValue;
30473 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
30475 export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
30476 if(!isWasmInitialized) {
30477 throw new Error("initializeWasm() must be awaited first!");
30479 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
30480 // debug statements here
30482 // struct LDKCOption_u32Z ChannelDetails_get_confirmations(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30484 export function ChannelDetails_get_confirmations(this_ptr: bigint): bigint {
30485 if(!isWasmInitialized) {
30486 throw new Error("initializeWasm() must be awaited first!");
30488 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations(this_ptr);
30489 return nativeResponseValue;
30491 // void ChannelDetails_set_confirmations(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
30493 export function ChannelDetails_set_confirmations(this_ptr: bigint, val: bigint): void {
30494 if(!isWasmInitialized) {
30495 throw new Error("initializeWasm() must be awaited first!");
30497 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations(this_ptr, val);
30498 // debug statements here
30500 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30502 export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
30503 if(!isWasmInitialized) {
30504 throw new Error("initializeWasm() must be awaited first!");
30506 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
30507 return nativeResponseValue;
30509 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
30511 export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
30512 if(!isWasmInitialized) {
30513 throw new Error("initializeWasm() must be awaited first!");
30515 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
30516 // debug statements here
30518 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30520 export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
30521 if(!isWasmInitialized) {
30522 throw new Error("initializeWasm() must be awaited first!");
30524 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
30525 return nativeResponseValue;
30527 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
30529 export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
30530 if(!isWasmInitialized) {
30531 throw new Error("initializeWasm() must be awaited first!");
30533 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
30534 // debug statements here
30536 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30538 export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
30539 if(!isWasmInitialized) {
30540 throw new Error("initializeWasm() must be awaited first!");
30542 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
30543 return nativeResponseValue;
30545 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
30547 export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
30548 if(!isWasmInitialized) {
30549 throw new Error("initializeWasm() must be awaited first!");
30551 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
30552 // debug statements here
30554 // struct LDKCOption_ChannelShutdownStateZ ChannelDetails_get_channel_shutdown_state(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30556 export function ChannelDetails_get_channel_shutdown_state(this_ptr: bigint): bigint {
30557 if(!isWasmInitialized) {
30558 throw new Error("initializeWasm() must be awaited first!");
30560 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_shutdown_state(this_ptr);
30561 return nativeResponseValue;
30563 // void ChannelDetails_set_channel_shutdown_state(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_ChannelShutdownStateZ val);
30565 export function ChannelDetails_set_channel_shutdown_state(this_ptr: bigint, val: bigint): void {
30566 if(!isWasmInitialized) {
30567 throw new Error("initializeWasm() must be awaited first!");
30569 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_shutdown_state(this_ptr, val);
30570 // debug statements here
30572 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30574 export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
30575 if(!isWasmInitialized) {
30576 throw new Error("initializeWasm() must be awaited first!");
30578 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
30579 return nativeResponseValue;
30581 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
30583 export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
30584 if(!isWasmInitialized) {
30585 throw new Error("initializeWasm() must be awaited first!");
30587 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
30588 // debug statements here
30590 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30592 export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
30593 if(!isWasmInitialized) {
30594 throw new Error("initializeWasm() must be awaited first!");
30596 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
30597 return nativeResponseValue;
30599 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
30601 export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
30602 if(!isWasmInitialized) {
30603 throw new Error("initializeWasm() must be awaited first!");
30605 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
30606 // debug statements here
30608 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30610 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
30611 if(!isWasmInitialized) {
30612 throw new Error("initializeWasm() must be awaited first!");
30614 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
30615 return nativeResponseValue;
30617 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30619 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
30620 if(!isWasmInitialized) {
30621 throw new Error("initializeWasm() must be awaited first!");
30623 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
30624 // debug statements here
30626 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30628 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
30629 if(!isWasmInitialized) {
30630 throw new Error("initializeWasm() must be awaited first!");
30632 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
30633 return nativeResponseValue;
30635 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30637 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
30638 if(!isWasmInitialized) {
30639 throw new Error("initializeWasm() must be awaited first!");
30641 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
30642 // debug statements here
30644 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
30646 export function ChannelDetails_get_config(this_ptr: bigint): bigint {
30647 if(!isWasmInitialized) {
30648 throw new Error("initializeWasm() must be awaited first!");
30650 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
30651 return nativeResponseValue;
30653 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
30655 export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
30656 if(!isWasmInitialized) {
30657 throw new Error("initializeWasm() must be awaited first!");
30659 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
30660 // debug statements here
30662 // 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);
30664 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 {
30665 if(!isWasmInitialized) {
30666 throw new Error("initializeWasm() must be awaited first!");
30668 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);
30669 return nativeResponseValue;
30671 // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
30673 export function ChannelDetails_clone_ptr(arg: bigint): bigint {
30674 if(!isWasmInitialized) {
30675 throw new Error("initializeWasm() must be awaited first!");
30677 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
30678 return nativeResponseValue;
30680 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
30682 export function ChannelDetails_clone(orig: bigint): bigint {
30683 if(!isWasmInitialized) {
30684 throw new Error("initializeWasm() must be awaited first!");
30686 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
30687 return nativeResponseValue;
30689 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
30691 export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
30692 if(!isWasmInitialized) {
30693 throw new Error("initializeWasm() must be awaited first!");
30695 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
30696 return nativeResponseValue;
30698 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
30700 export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
30701 if(!isWasmInitialized) {
30702 throw new Error("initializeWasm() must be awaited first!");
30704 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
30705 return nativeResponseValue;
30707 // enum LDKChannelShutdownState ChannelShutdownState_clone(const enum LDKChannelShutdownState *NONNULL_PTR orig);
30709 export function ChannelShutdownState_clone(orig: bigint): ChannelShutdownState {
30710 if(!isWasmInitialized) {
30711 throw new Error("initializeWasm() must be awaited first!");
30713 const nativeResponseValue = wasm.TS_ChannelShutdownState_clone(orig);
30714 return nativeResponseValue;
30716 // enum LDKChannelShutdownState ChannelShutdownState_not_shutting_down(void);
30718 export function ChannelShutdownState_not_shutting_down(): ChannelShutdownState {
30719 if(!isWasmInitialized) {
30720 throw new Error("initializeWasm() must be awaited first!");
30722 const nativeResponseValue = wasm.TS_ChannelShutdownState_not_shutting_down();
30723 return nativeResponseValue;
30725 // enum LDKChannelShutdownState ChannelShutdownState_shutdown_initiated(void);
30727 export function ChannelShutdownState_shutdown_initiated(): ChannelShutdownState {
30728 if(!isWasmInitialized) {
30729 throw new Error("initializeWasm() must be awaited first!");
30731 const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_initiated();
30732 return nativeResponseValue;
30734 // enum LDKChannelShutdownState ChannelShutdownState_resolving_htlcs(void);
30736 export function ChannelShutdownState_resolving_htlcs(): ChannelShutdownState {
30737 if(!isWasmInitialized) {
30738 throw new Error("initializeWasm() must be awaited first!");
30740 const nativeResponseValue = wasm.TS_ChannelShutdownState_resolving_htlcs();
30741 return nativeResponseValue;
30743 // enum LDKChannelShutdownState ChannelShutdownState_negotiating_closing_fee(void);
30745 export function ChannelShutdownState_negotiating_closing_fee(): ChannelShutdownState {
30746 if(!isWasmInitialized) {
30747 throw new Error("initializeWasm() must be awaited first!");
30749 const nativeResponseValue = wasm.TS_ChannelShutdownState_negotiating_closing_fee();
30750 return nativeResponseValue;
30752 // enum LDKChannelShutdownState ChannelShutdownState_shutdown_complete(void);
30754 export function ChannelShutdownState_shutdown_complete(): ChannelShutdownState {
30755 if(!isWasmInitialized) {
30756 throw new Error("initializeWasm() must be awaited first!");
30758 const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_complete();
30759 return nativeResponseValue;
30761 // bool ChannelShutdownState_eq(const enum LDKChannelShutdownState *NONNULL_PTR a, const enum LDKChannelShutdownState *NONNULL_PTR b);
30763 export function ChannelShutdownState_eq(a: bigint, b: bigint): boolean {
30764 if(!isWasmInitialized) {
30765 throw new Error("initializeWasm() must be awaited first!");
30767 const nativeResponseValue = wasm.TS_ChannelShutdownState_eq(a, b);
30768 return nativeResponseValue;
30770 // void RecentPaymentDetails_free(struct LDKRecentPaymentDetails this_ptr);
30772 export function RecentPaymentDetails_free(this_ptr: bigint): void {
30773 if(!isWasmInitialized) {
30774 throw new Error("initializeWasm() must be awaited first!");
30776 const nativeResponseValue = wasm.TS_RecentPaymentDetails_free(this_ptr);
30777 // debug statements here
30779 // uint64_t RecentPaymentDetails_clone_ptr(LDKRecentPaymentDetails *NONNULL_PTR arg);
30781 export function RecentPaymentDetails_clone_ptr(arg: bigint): bigint {
30782 if(!isWasmInitialized) {
30783 throw new Error("initializeWasm() must be awaited first!");
30785 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone_ptr(arg);
30786 return nativeResponseValue;
30788 // struct LDKRecentPaymentDetails RecentPaymentDetails_clone(const struct LDKRecentPaymentDetails *NONNULL_PTR orig);
30790 export function RecentPaymentDetails_clone(orig: bigint): bigint {
30791 if(!isWasmInitialized) {
30792 throw new Error("initializeWasm() must be awaited first!");
30794 const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone(orig);
30795 return nativeResponseValue;
30797 // struct LDKRecentPaymentDetails RecentPaymentDetails_awaiting_invoice(struct LDKThirtyTwoBytes payment_id);
30799 export function RecentPaymentDetails_awaiting_invoice(payment_id: number): bigint {
30800 if(!isWasmInitialized) {
30801 throw new Error("initializeWasm() must be awaited first!");
30803 const nativeResponseValue = wasm.TS_RecentPaymentDetails_awaiting_invoice(payment_id);
30804 return nativeResponseValue;
30806 // struct LDKRecentPaymentDetails RecentPaymentDetails_pending(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, uint64_t total_msat);
30808 export function RecentPaymentDetails_pending(payment_id: number, payment_hash: number, total_msat: bigint): bigint {
30809 if(!isWasmInitialized) {
30810 throw new Error("initializeWasm() must be awaited first!");
30812 const nativeResponseValue = wasm.TS_RecentPaymentDetails_pending(payment_id, payment_hash, total_msat);
30813 return nativeResponseValue;
30815 // struct LDKRecentPaymentDetails RecentPaymentDetails_fulfilled(struct LDKThirtyTwoBytes payment_id, struct LDKCOption_ThirtyTwoBytesZ payment_hash);
30817 export function RecentPaymentDetails_fulfilled(payment_id: number, payment_hash: bigint): bigint {
30818 if(!isWasmInitialized) {
30819 throw new Error("initializeWasm() must be awaited first!");
30821 const nativeResponseValue = wasm.TS_RecentPaymentDetails_fulfilled(payment_id, payment_hash);
30822 return nativeResponseValue;
30824 // struct LDKRecentPaymentDetails RecentPaymentDetails_abandoned(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
30826 export function RecentPaymentDetails_abandoned(payment_id: number, payment_hash: number): bigint {
30827 if(!isWasmInitialized) {
30828 throw new Error("initializeWasm() must be awaited first!");
30830 const nativeResponseValue = wasm.TS_RecentPaymentDetails_abandoned(payment_id, payment_hash);
30831 return nativeResponseValue;
30833 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
30835 export function PhantomRouteHints_free(this_obj: bigint): void {
30836 if(!isWasmInitialized) {
30837 throw new Error("initializeWasm() must be awaited first!");
30839 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
30840 // debug statements here
30842 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
30844 export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
30845 if(!isWasmInitialized) {
30846 throw new Error("initializeWasm() must be awaited first!");
30848 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
30849 return nativeResponseValue;
30851 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
30853 export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
30854 if(!isWasmInitialized) {
30855 throw new Error("initializeWasm() must be awaited first!");
30857 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
30858 // debug statements here
30860 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
30862 export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
30863 if(!isWasmInitialized) {
30864 throw new Error("initializeWasm() must be awaited first!");
30866 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
30867 return nativeResponseValue;
30869 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
30871 export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
30872 if(!isWasmInitialized) {
30873 throw new Error("initializeWasm() must be awaited first!");
30875 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
30876 // debug statements here
30878 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
30880 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
30881 if(!isWasmInitialized) {
30882 throw new Error("initializeWasm() must be awaited first!");
30884 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
30885 return nativeResponseValue;
30887 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30889 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
30890 if(!isWasmInitialized) {
30891 throw new Error("initializeWasm() must be awaited first!");
30893 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
30894 // debug statements here
30896 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
30898 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
30899 if(!isWasmInitialized) {
30900 throw new Error("initializeWasm() must be awaited first!");
30902 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
30903 return nativeResponseValue;
30905 // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
30907 export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
30908 if(!isWasmInitialized) {
30909 throw new Error("initializeWasm() must be awaited first!");
30911 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
30912 return nativeResponseValue;
30914 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
30916 export function PhantomRouteHints_clone(orig: bigint): bigint {
30917 if(!isWasmInitialized) {
30918 throw new Error("initializeWasm() must be awaited first!");
30920 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
30921 return nativeResponseValue;
30923 // 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);
30925 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 {
30926 if(!isWasmInitialized) {
30927 throw new Error("initializeWasm() must be awaited first!");
30929 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, router, logger, entropy_source, node_signer, signer_provider, config, params, current_timestamp);
30930 return nativeResponseValue;
30932 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
30934 export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
30935 if(!isWasmInitialized) {
30936 throw new Error("initializeWasm() must be awaited first!");
30938 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
30939 return nativeResponseValue;
30941 // 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 LDKCOption_ThirtyTwoBytesZ temporary_channel_id, struct LDKUserConfig override_config);
30943 export function ChannelManager_create_channel(this_arg: bigint, their_network_key: number, channel_value_satoshis: bigint, push_msat: bigint, user_channel_id: number, temporary_channel_id: bigint, override_config: bigint): bigint {
30944 if(!isWasmInitialized) {
30945 throw new Error("initializeWasm() must be awaited first!");
30947 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, temporary_channel_id, override_config);
30948 return nativeResponseValue;
30950 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
30952 export function ChannelManager_list_channels(this_arg: bigint): number {
30953 if(!isWasmInitialized) {
30954 throw new Error("initializeWasm() must be awaited first!");
30956 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
30957 return nativeResponseValue;
30959 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
30961 export function ChannelManager_list_usable_channels(this_arg: bigint): number {
30962 if(!isWasmInitialized) {
30963 throw new Error("initializeWasm() must be awaited first!");
30965 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
30966 return nativeResponseValue;
30968 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels_with_counterparty(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id);
30970 export function ChannelManager_list_channels_with_counterparty(this_arg: bigint, counterparty_node_id: number): number {
30971 if(!isWasmInitialized) {
30972 throw new Error("initializeWasm() must be awaited first!");
30974 const nativeResponseValue = wasm.TS_ChannelManager_list_channels_with_counterparty(this_arg, counterparty_node_id);
30975 return nativeResponseValue;
30977 // MUST_USE_RES struct LDKCVec_RecentPaymentDetailsZ ChannelManager_list_recent_payments(const struct LDKChannelManager *NONNULL_PTR this_arg);
30979 export function ChannelManager_list_recent_payments(this_arg: bigint): number {
30980 if(!isWasmInitialized) {
30981 throw new Error("initializeWasm() must be awaited first!");
30983 const nativeResponseValue = wasm.TS_ChannelManager_list_recent_payments(this_arg);
30984 return nativeResponseValue;
30986 // 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);
30988 export function ChannelManager_close_channel(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
30989 if(!isWasmInitialized) {
30990 throw new Error("initializeWasm() must be awaited first!");
30992 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
30993 return nativeResponseValue;
30995 // 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);
30997 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 {
30998 if(!isWasmInitialized) {
30999 throw new Error("initializeWasm() must be awaited first!");
31001 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);
31002 return nativeResponseValue;
31004 // 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);
31006 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
31007 if(!isWasmInitialized) {
31008 throw new Error("initializeWasm() must be awaited first!");
31010 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
31011 return nativeResponseValue;
31013 // 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);
31015 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: number, counterparty_node_id: number): bigint {
31016 if(!isWasmInitialized) {
31017 throw new Error("initializeWasm() must be awaited first!");
31019 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
31020 return nativeResponseValue;
31022 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
31024 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
31025 if(!isWasmInitialized) {
31026 throw new Error("initializeWasm() must be awaited first!");
31028 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
31029 // debug statements here
31031 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
31033 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
31034 if(!isWasmInitialized) {
31035 throw new Error("initializeWasm() must be awaited first!");
31037 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
31038 // debug statements here
31040 // 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);
31042 export function ChannelManager_send_payment_with_route(this_arg: bigint, route: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number): bigint {
31043 if(!isWasmInitialized) {
31044 throw new Error("initializeWasm() must be awaited first!");
31046 const nativeResponseValue = wasm.TS_ChannelManager_send_payment_with_route(this_arg, route, payment_hash, recipient_onion, payment_id);
31047 return nativeResponseValue;
31049 // 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);
31051 export function ChannelManager_send_payment(this_arg: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
31052 if(!isWasmInitialized) {
31053 throw new Error("initializeWasm() must be awaited first!");
31055 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, payment_hash, recipient_onion, payment_id, route_params, retry_strategy);
31056 return nativeResponseValue;
31058 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
31060 export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
31061 if(!isWasmInitialized) {
31062 throw new Error("initializeWasm() must be awaited first!");
31064 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
31065 // debug statements here
31067 // 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);
31069 export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: bigint, recipient_onion: bigint, payment_id: number): bigint {
31070 if(!isWasmInitialized) {
31071 throw new Error("initializeWasm() must be awaited first!");
31073 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage, recipient_onion, payment_id);
31074 return nativeResponseValue;
31076 // 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);
31078 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 {
31079 if(!isWasmInitialized) {
31080 throw new Error("initializeWasm() must be awaited first!");
31082 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment_with_retry(this_arg, payment_preimage, recipient_onion, payment_id, route_params, retry_strategy);
31083 return nativeResponseValue;
31085 // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPath path);
31087 export function ChannelManager_send_probe(this_arg: bigint, path: bigint): bigint {
31088 if(!isWasmInitialized) {
31089 throw new Error("initializeWasm() must be awaited first!");
31091 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, path);
31092 return nativeResponseValue;
31094 // 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);
31096 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 {
31097 if(!isWasmInitialized) {
31098 throw new Error("initializeWasm() must be awaited first!");
31100 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_preflight_probes(this_arg, node_id, amount_msat, final_cltv_expiry_delta, liquidity_limit_multiplier);
31101 return nativeResponseValue;
31103 // 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);
31105 export function ChannelManager_send_preflight_probes(this_arg: bigint, route_params: bigint, liquidity_limit_multiplier: bigint): bigint {
31106 if(!isWasmInitialized) {
31107 throw new Error("initializeWasm() must be awaited first!");
31109 const nativeResponseValue = wasm.TS_ChannelManager_send_preflight_probes(this_arg, route_params, liquidity_limit_multiplier);
31110 return nativeResponseValue;
31112 // 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);
31114 export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): bigint {
31115 if(!isWasmInitialized) {
31116 throw new Error("initializeWasm() must be awaited first!");
31118 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
31119 return nativeResponseValue;
31121 // 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);
31123 export function ChannelManager_batch_funding_transaction_generated(this_arg: bigint, temporary_channels: number, funding_transaction: number): bigint {
31124 if(!isWasmInitialized) {
31125 throw new Error("initializeWasm() must be awaited first!");
31127 const nativeResponseValue = wasm.TS_ChannelManager_batch_funding_transaction_generated(this_arg, temporary_channels, funding_transaction);
31128 return nativeResponseValue;
31130 // 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);
31132 export function ChannelManager_update_partial_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config_update: bigint): bigint {
31133 if(!isWasmInitialized) {
31134 throw new Error("initializeWasm() must be awaited first!");
31136 const nativeResponseValue = wasm.TS_ChannelManager_update_partial_channel_config(this_arg, counterparty_node_id, channel_ids, config_update);
31137 return nativeResponseValue;
31139 // 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);
31141 export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
31142 if(!isWasmInitialized) {
31143 throw new Error("initializeWasm() must be awaited first!");
31145 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
31146 return nativeResponseValue;
31148 // 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);
31150 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 {
31151 if(!isWasmInitialized) {
31152 throw new Error("initializeWasm() must be awaited first!");
31154 const nativeResponseValue = wasm.TS_ChannelManager_forward_intercepted_htlc(this_arg, intercept_id, next_hop_channel_id, next_node_id, amt_to_forward_msat);
31155 return nativeResponseValue;
31157 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_fail_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id);
31159 export function ChannelManager_fail_intercepted_htlc(this_arg: bigint, intercept_id: number): bigint {
31160 if(!isWasmInitialized) {
31161 throw new Error("initializeWasm() must be awaited first!");
31163 const nativeResponseValue = wasm.TS_ChannelManager_fail_intercepted_htlc(this_arg, intercept_id);
31164 return nativeResponseValue;
31166 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
31168 export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
31169 if(!isWasmInitialized) {
31170 throw new Error("initializeWasm() must be awaited first!");
31172 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
31173 // debug statements here
31175 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
31177 export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
31178 if(!isWasmInitialized) {
31179 throw new Error("initializeWasm() must be awaited first!");
31181 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
31182 // debug statements here
31184 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
31186 export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
31187 if(!isWasmInitialized) {
31188 throw new Error("initializeWasm() must be awaited first!");
31190 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
31191 // debug statements here
31193 // void ChannelManager_fail_htlc_backwards_with_reason(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32], struct LDKFailureCode failure_code);
31195 export function ChannelManager_fail_htlc_backwards_with_reason(this_arg: bigint, payment_hash: number, failure_code: bigint): void {
31196 if(!isWasmInitialized) {
31197 throw new Error("initializeWasm() must be awaited first!");
31199 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards_with_reason(this_arg, payment_hash, failure_code);
31200 // debug statements here
31202 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
31204 export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
31205 if(!isWasmInitialized) {
31206 throw new Error("initializeWasm() must be awaited first!");
31208 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
31209 // debug statements here
31211 // void ChannelManager_claim_funds_with_known_custom_tlvs(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
31213 export function ChannelManager_claim_funds_with_known_custom_tlvs(this_arg: bigint, payment_preimage: number): void {
31214 if(!isWasmInitialized) {
31215 throw new Error("initializeWasm() must be awaited first!");
31217 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds_with_known_custom_tlvs(this_arg, payment_preimage);
31218 // debug statements here
31220 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
31222 export function ChannelManager_get_our_node_id(this_arg: bigint): number {
31223 if(!isWasmInitialized) {
31224 throw new Error("initializeWasm() must be awaited first!");
31226 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
31227 return nativeResponseValue;
31229 // 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);
31231 export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: number): bigint {
31232 if(!isWasmInitialized) {
31233 throw new Error("initializeWasm() must be awaited first!");
31235 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
31236 return nativeResponseValue;
31238 // 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);
31240 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 {
31241 if(!isWasmInitialized) {
31242 throw new Error("initializeWasm() must be awaited first!");
31244 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
31245 return nativeResponseValue;
31247 // 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);
31249 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 {
31250 if(!isWasmInitialized) {
31251 throw new Error("initializeWasm() must be awaited first!");
31253 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);
31254 return nativeResponseValue;
31256 // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ ChannelManager_request_refund_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRefund *NONNULL_PTR refund);
31258 export function ChannelManager_request_refund_payment(this_arg: bigint, refund: bigint): bigint {
31259 if(!isWasmInitialized) {
31260 throw new Error("initializeWasm() must be awaited first!");
31262 const nativeResponseValue = wasm.TS_ChannelManager_request_refund_payment(this_arg, refund);
31263 return nativeResponseValue;
31265 // 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);
31267 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 {
31268 if(!isWasmInitialized) {
31269 throw new Error("initializeWasm() must be awaited first!");
31271 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
31272 return nativeResponseValue;
31274 // 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);
31276 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 {
31277 if(!isWasmInitialized) {
31278 throw new Error("initializeWasm() must be awaited first!");
31280 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);
31281 return nativeResponseValue;
31283 // 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);
31285 export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
31286 if(!isWasmInitialized) {
31287 throw new Error("initializeWasm() must be awaited first!");
31289 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
31290 return nativeResponseValue;
31292 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
31294 export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
31295 if(!isWasmInitialized) {
31296 throw new Error("initializeWasm() must be awaited first!");
31298 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
31299 return nativeResponseValue;
31301 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
31303 export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
31304 if(!isWasmInitialized) {
31305 throw new Error("initializeWasm() must be awaited first!");
31307 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
31308 return nativeResponseValue;
31310 // MUST_USE_RES uint64_t ChannelManager_get_intercept_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
31312 export function ChannelManager_get_intercept_scid(this_arg: bigint): bigint {
31313 if(!isWasmInitialized) {
31314 throw new Error("initializeWasm() must be awaited first!");
31316 const nativeResponseValue = wasm.TS_ChannelManager_get_intercept_scid(this_arg);
31317 return nativeResponseValue;
31319 // MUST_USE_RES struct LDKInFlightHtlcs ChannelManager_compute_inflight_htlcs(const struct LDKChannelManager *NONNULL_PTR this_arg);
31321 export function ChannelManager_compute_inflight_htlcs(this_arg: bigint): bigint {
31322 if(!isWasmInitialized) {
31323 throw new Error("initializeWasm() must be awaited first!");
31325 const nativeResponseValue = wasm.TS_ChannelManager_compute_inflight_htlcs(this_arg);
31326 return nativeResponseValue;
31328 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
31330 export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
31331 if(!isWasmInitialized) {
31332 throw new Error("initializeWasm() must be awaited first!");
31334 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
31335 return nativeResponseValue;
31337 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
31339 export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
31340 if(!isWasmInitialized) {
31341 throw new Error("initializeWasm() must be awaited first!");
31343 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
31344 return nativeResponseValue;
31346 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
31348 export function ChannelManager_as_Listen(this_arg: bigint): bigint {
31349 if(!isWasmInitialized) {
31350 throw new Error("initializeWasm() must be awaited first!");
31352 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
31353 return nativeResponseValue;
31355 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
31357 export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
31358 if(!isWasmInitialized) {
31359 throw new Error("initializeWasm() must be awaited first!");
31361 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
31362 return nativeResponseValue;
31364 // MUST_USE_RES struct LDKFuture ChannelManager_get_event_or_persistence_needed_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
31366 export function ChannelManager_get_event_or_persistence_needed_future(this_arg: bigint): bigint {
31367 if(!isWasmInitialized) {
31368 throw new Error("initializeWasm() must be awaited first!");
31370 const nativeResponseValue = wasm.TS_ChannelManager_get_event_or_persistence_needed_future(this_arg);
31371 return nativeResponseValue;
31373 // MUST_USE_RES bool ChannelManager_get_and_clear_needs_persistence(const struct LDKChannelManager *NONNULL_PTR this_arg);
31375 export function ChannelManager_get_and_clear_needs_persistence(this_arg: bigint): boolean {
31376 if(!isWasmInitialized) {
31377 throw new Error("initializeWasm() must be awaited first!");
31379 const nativeResponseValue = wasm.TS_ChannelManager_get_and_clear_needs_persistence(this_arg);
31380 return nativeResponseValue;
31382 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
31384 export function ChannelManager_current_best_block(this_arg: bigint): bigint {
31385 if(!isWasmInitialized) {
31386 throw new Error("initializeWasm() must be awaited first!");
31388 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
31389 return nativeResponseValue;
31391 // MUST_USE_RES struct LDKNodeFeatures ChannelManager_node_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
31393 export function ChannelManager_node_features(this_arg: bigint): bigint {
31394 if(!isWasmInitialized) {
31395 throw new Error("initializeWasm() must be awaited first!");
31397 const nativeResponseValue = wasm.TS_ChannelManager_node_features(this_arg);
31398 return nativeResponseValue;
31400 // MUST_USE_RES struct LDKChannelFeatures ChannelManager_channel_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
31402 export function ChannelManager_channel_features(this_arg: bigint): bigint {
31403 if(!isWasmInitialized) {
31404 throw new Error("initializeWasm() must be awaited first!");
31406 const nativeResponseValue = wasm.TS_ChannelManager_channel_features(this_arg);
31407 return nativeResponseValue;
31409 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelManager_channel_type_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
31411 export function ChannelManager_channel_type_features(this_arg: bigint): bigint {
31412 if(!isWasmInitialized) {
31413 throw new Error("initializeWasm() must be awaited first!");
31415 const nativeResponseValue = wasm.TS_ChannelManager_channel_type_features(this_arg);
31416 return nativeResponseValue;
31418 // MUST_USE_RES struct LDKInitFeatures ChannelManager_init_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
31420 export function ChannelManager_init_features(this_arg: bigint): bigint {
31421 if(!isWasmInitialized) {
31422 throw new Error("initializeWasm() must be awaited first!");
31424 const nativeResponseValue = wasm.TS_ChannelManager_init_features(this_arg);
31425 return nativeResponseValue;
31427 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
31429 export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
31430 if(!isWasmInitialized) {
31431 throw new Error("initializeWasm() must be awaited first!");
31433 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
31434 return nativeResponseValue;
31436 // struct LDKOffersMessageHandler ChannelManager_as_OffersMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
31438 export function ChannelManager_as_OffersMessageHandler(this_arg: bigint): bigint {
31439 if(!isWasmInitialized) {
31440 throw new Error("initializeWasm() must be awaited first!");
31442 const nativeResponseValue = wasm.TS_ChannelManager_as_OffersMessageHandler(this_arg);
31443 return nativeResponseValue;
31445 // struct LDKInitFeatures provided_init_features(const struct LDKUserConfig *NONNULL_PTR config);
31447 export function provided_init_features(config: bigint): bigint {
31448 if(!isWasmInitialized) {
31449 throw new Error("initializeWasm() must be awaited first!");
31451 const nativeResponseValue = wasm.TS_provided_init_features(config);
31452 return nativeResponseValue;
31454 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
31456 export function CounterpartyForwardingInfo_write(obj: bigint): number {
31457 if(!isWasmInitialized) {
31458 throw new Error("initializeWasm() must be awaited first!");
31460 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
31461 return nativeResponseValue;
31463 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
31465 export function CounterpartyForwardingInfo_read(ser: number): bigint {
31466 if(!isWasmInitialized) {
31467 throw new Error("initializeWasm() must be awaited first!");
31469 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
31470 return nativeResponseValue;
31472 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
31474 export function ChannelCounterparty_write(obj: bigint): number {
31475 if(!isWasmInitialized) {
31476 throw new Error("initializeWasm() must be awaited first!");
31478 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
31479 return nativeResponseValue;
31481 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
31483 export function ChannelCounterparty_read(ser: number): bigint {
31484 if(!isWasmInitialized) {
31485 throw new Error("initializeWasm() must be awaited first!");
31487 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
31488 return nativeResponseValue;
31490 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
31492 export function ChannelDetails_write(obj: bigint): number {
31493 if(!isWasmInitialized) {
31494 throw new Error("initializeWasm() must be awaited first!");
31496 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
31497 return nativeResponseValue;
31499 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
31501 export function ChannelDetails_read(ser: number): bigint {
31502 if(!isWasmInitialized) {
31503 throw new Error("initializeWasm() must be awaited first!");
31505 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
31506 return nativeResponseValue;
31508 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
31510 export function PhantomRouteHints_write(obj: bigint): number {
31511 if(!isWasmInitialized) {
31512 throw new Error("initializeWasm() must be awaited first!");
31514 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
31515 return nativeResponseValue;
31517 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
31519 export function PhantomRouteHints_read(ser: number): bigint {
31520 if(!isWasmInitialized) {
31521 throw new Error("initializeWasm() must be awaited first!");
31523 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
31524 return nativeResponseValue;
31526 // struct LDKCVec_u8Z BlindedForward_write(const struct LDKBlindedForward *NONNULL_PTR obj);
31528 export function BlindedForward_write(obj: bigint): number {
31529 if(!isWasmInitialized) {
31530 throw new Error("initializeWasm() must be awaited first!");
31532 const nativeResponseValue = wasm.TS_BlindedForward_write(obj);
31533 return nativeResponseValue;
31535 // struct LDKCResult_BlindedForwardDecodeErrorZ BlindedForward_read(struct LDKu8slice ser);
31537 export function BlindedForward_read(ser: number): bigint {
31538 if(!isWasmInitialized) {
31539 throw new Error("initializeWasm() must be awaited first!");
31541 const nativeResponseValue = wasm.TS_BlindedForward_read(ser);
31542 return nativeResponseValue;
31544 // struct LDKCVec_u8Z PendingHTLCRouting_write(const struct LDKPendingHTLCRouting *NONNULL_PTR obj);
31546 export function PendingHTLCRouting_write(obj: bigint): number {
31547 if(!isWasmInitialized) {
31548 throw new Error("initializeWasm() must be awaited first!");
31550 const nativeResponseValue = wasm.TS_PendingHTLCRouting_write(obj);
31551 return nativeResponseValue;
31553 // struct LDKCResult_PendingHTLCRoutingDecodeErrorZ PendingHTLCRouting_read(struct LDKu8slice ser);
31555 export function PendingHTLCRouting_read(ser: number): bigint {
31556 if(!isWasmInitialized) {
31557 throw new Error("initializeWasm() must be awaited first!");
31559 const nativeResponseValue = wasm.TS_PendingHTLCRouting_read(ser);
31560 return nativeResponseValue;
31562 // struct LDKCVec_u8Z PendingHTLCInfo_write(const struct LDKPendingHTLCInfo *NONNULL_PTR obj);
31564 export function PendingHTLCInfo_write(obj: bigint): number {
31565 if(!isWasmInitialized) {
31566 throw new Error("initializeWasm() must be awaited first!");
31568 const nativeResponseValue = wasm.TS_PendingHTLCInfo_write(obj);
31569 return nativeResponseValue;
31571 // struct LDKCResult_PendingHTLCInfoDecodeErrorZ PendingHTLCInfo_read(struct LDKu8slice ser);
31573 export function PendingHTLCInfo_read(ser: number): bigint {
31574 if(!isWasmInitialized) {
31575 throw new Error("initializeWasm() must be awaited first!");
31577 const nativeResponseValue = wasm.TS_PendingHTLCInfo_read(ser);
31578 return nativeResponseValue;
31580 // struct LDKCVec_u8Z BlindedFailure_write(const enum LDKBlindedFailure *NONNULL_PTR obj);
31582 export function BlindedFailure_write(obj: bigint): number {
31583 if(!isWasmInitialized) {
31584 throw new Error("initializeWasm() must be awaited first!");
31586 const nativeResponseValue = wasm.TS_BlindedFailure_write(obj);
31587 return nativeResponseValue;
31589 // struct LDKCResult_BlindedFailureDecodeErrorZ BlindedFailure_read(struct LDKu8slice ser);
31591 export function BlindedFailure_read(ser: number): bigint {
31592 if(!isWasmInitialized) {
31593 throw new Error("initializeWasm() must be awaited first!");
31595 const nativeResponseValue = wasm.TS_BlindedFailure_read(ser);
31596 return nativeResponseValue;
31598 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
31600 export function ChannelManager_write(obj: bigint): number {
31601 if(!isWasmInitialized) {
31602 throw new Error("initializeWasm() must be awaited first!");
31604 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
31605 return nativeResponseValue;
31607 // struct LDKCVec_u8Z ChannelShutdownState_write(const enum LDKChannelShutdownState *NONNULL_PTR obj);
31609 export function ChannelShutdownState_write(obj: bigint): number {
31610 if(!isWasmInitialized) {
31611 throw new Error("initializeWasm() must be awaited first!");
31613 const nativeResponseValue = wasm.TS_ChannelShutdownState_write(obj);
31614 return nativeResponseValue;
31616 // struct LDKCResult_ChannelShutdownStateDecodeErrorZ ChannelShutdownState_read(struct LDKu8slice ser);
31618 export function ChannelShutdownState_read(ser: number): bigint {
31619 if(!isWasmInitialized) {
31620 throw new Error("initializeWasm() must be awaited first!");
31622 const nativeResponseValue = wasm.TS_ChannelShutdownState_read(ser);
31623 return nativeResponseValue;
31625 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
31627 export function ChannelManagerReadArgs_free(this_obj: bigint): void {
31628 if(!isWasmInitialized) {
31629 throw new Error("initializeWasm() must be awaited first!");
31631 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
31632 // debug statements here
31634 // const struct LDKEntropySource *ChannelManagerReadArgs_get_entropy_source(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
31636 export function ChannelManagerReadArgs_get_entropy_source(this_ptr: bigint): bigint {
31637 if(!isWasmInitialized) {
31638 throw new Error("initializeWasm() must be awaited first!");
31640 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_entropy_source(this_ptr);
31641 return nativeResponseValue;
31643 // void ChannelManagerReadArgs_set_entropy_source(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKEntropySource val);
31645 export function ChannelManagerReadArgs_set_entropy_source(this_ptr: bigint, val: bigint): void {
31646 if(!isWasmInitialized) {
31647 throw new Error("initializeWasm() must be awaited first!");
31649 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_entropy_source(this_ptr, val);
31650 // debug statements here
31652 // const struct LDKNodeSigner *ChannelManagerReadArgs_get_node_signer(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
31654 export function ChannelManagerReadArgs_get_node_signer(this_ptr: bigint): bigint {
31655 if(!isWasmInitialized) {
31656 throw new Error("initializeWasm() must be awaited first!");
31658 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_node_signer(this_ptr);
31659 return nativeResponseValue;
31661 // void ChannelManagerReadArgs_set_node_signer(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKNodeSigner val);
31663 export function ChannelManagerReadArgs_set_node_signer(this_ptr: bigint, val: bigint): void {
31664 if(!isWasmInitialized) {
31665 throw new Error("initializeWasm() must be awaited first!");
31667 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_node_signer(this_ptr, val);
31668 // debug statements here
31670 // const struct LDKSignerProvider *ChannelManagerReadArgs_get_signer_provider(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
31672 export function ChannelManagerReadArgs_get_signer_provider(this_ptr: bigint): bigint {
31673 if(!isWasmInitialized) {
31674 throw new Error("initializeWasm() must be awaited first!");
31676 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_signer_provider(this_ptr);
31677 return nativeResponseValue;
31679 // void ChannelManagerReadArgs_set_signer_provider(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKSignerProvider val);
31681 export function ChannelManagerReadArgs_set_signer_provider(this_ptr: bigint, val: bigint): void {
31682 if(!isWasmInitialized) {
31683 throw new Error("initializeWasm() must be awaited first!");
31685 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_signer_provider(this_ptr, val);
31686 // debug statements here
31688 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
31690 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
31691 if(!isWasmInitialized) {
31692 throw new Error("initializeWasm() must be awaited first!");
31694 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
31695 return nativeResponseValue;
31697 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
31699 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
31700 if(!isWasmInitialized) {
31701 throw new Error("initializeWasm() must be awaited first!");
31703 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
31704 // debug statements here
31706 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
31708 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
31709 if(!isWasmInitialized) {
31710 throw new Error("initializeWasm() must be awaited first!");
31712 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
31713 return nativeResponseValue;
31715 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
31717 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
31718 if(!isWasmInitialized) {
31719 throw new Error("initializeWasm() must be awaited first!");
31721 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
31722 // debug statements here
31724 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
31726 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
31727 if(!isWasmInitialized) {
31728 throw new Error("initializeWasm() must be awaited first!");
31730 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
31731 return nativeResponseValue;
31733 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
31735 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
31736 if(!isWasmInitialized) {
31737 throw new Error("initializeWasm() must be awaited first!");
31739 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
31740 // debug statements here
31742 // const struct LDKRouter *ChannelManagerReadArgs_get_router(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
31744 export function ChannelManagerReadArgs_get_router(this_ptr: bigint): bigint {
31745 if(!isWasmInitialized) {
31746 throw new Error("initializeWasm() must be awaited first!");
31748 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_router(this_ptr);
31749 return nativeResponseValue;
31751 // void ChannelManagerReadArgs_set_router(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKRouter val);
31753 export function ChannelManagerReadArgs_set_router(this_ptr: bigint, val: bigint): void {
31754 if(!isWasmInitialized) {
31755 throw new Error("initializeWasm() must be awaited first!");
31757 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_router(this_ptr, val);
31758 // debug statements here
31760 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
31762 export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
31763 if(!isWasmInitialized) {
31764 throw new Error("initializeWasm() must be awaited first!");
31766 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
31767 return nativeResponseValue;
31769 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
31771 export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
31772 if(!isWasmInitialized) {
31773 throw new Error("initializeWasm() must be awaited first!");
31775 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
31776 // debug statements here
31778 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
31780 export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
31781 if(!isWasmInitialized) {
31782 throw new Error("initializeWasm() must be awaited first!");
31784 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
31785 return nativeResponseValue;
31787 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
31789 export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
31790 if(!isWasmInitialized) {
31791 throw new Error("initializeWasm() must be awaited first!");
31793 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
31794 // debug statements here
31796 // 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);
31798 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 {
31799 if(!isWasmInitialized) {
31800 throw new Error("initializeWasm() must be awaited first!");
31802 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(entropy_source, node_signer, signer_provider, fee_estimator, chain_monitor, tx_broadcaster, router, logger, default_config, channel_monitors);
31803 return nativeResponseValue;
31805 // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ C2Tuple_ThirtyTwoBytesChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
31807 export function C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser: number, arg: bigint): bigint {
31808 if(!isWasmInitialized) {
31809 throw new Error("initializeWasm() must be awaited first!");
31811 const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser, arg);
31812 return nativeResponseValue;
31814 // void DelayedPaymentBasepoint_free(struct LDKDelayedPaymentBasepoint this_obj);
31816 export function DelayedPaymentBasepoint_free(this_obj: bigint): void {
31817 if(!isWasmInitialized) {
31818 throw new Error("initializeWasm() must be awaited first!");
31820 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_free(this_obj);
31821 // debug statements here
31823 // struct LDKPublicKey DelayedPaymentBasepoint_get_a(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_ptr);
31825 export function DelayedPaymentBasepoint_get_a(this_ptr: bigint): number {
31826 if(!isWasmInitialized) {
31827 throw new Error("initializeWasm() must be awaited first!");
31829 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_get_a(this_ptr);
31830 return nativeResponseValue;
31832 // void DelayedPaymentBasepoint_set_a(struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31834 export function DelayedPaymentBasepoint_set_a(this_ptr: bigint, val: number): void {
31835 if(!isWasmInitialized) {
31836 throw new Error("initializeWasm() must be awaited first!");
31838 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_set_a(this_ptr, val);
31839 // debug statements here
31841 // MUST_USE_RES struct LDKDelayedPaymentBasepoint DelayedPaymentBasepoint_new(struct LDKPublicKey a_arg);
31843 export function DelayedPaymentBasepoint_new(a_arg: number): bigint {
31844 if(!isWasmInitialized) {
31845 throw new Error("initializeWasm() must be awaited first!");
31847 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_new(a_arg);
31848 return nativeResponseValue;
31850 // bool DelayedPaymentBasepoint_eq(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR a, const struct LDKDelayedPaymentBasepoint *NONNULL_PTR b);
31852 export function DelayedPaymentBasepoint_eq(a: bigint, b: bigint): boolean {
31853 if(!isWasmInitialized) {
31854 throw new Error("initializeWasm() must be awaited first!");
31856 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_eq(a, b);
31857 return nativeResponseValue;
31859 // uint64_t DelayedPaymentBasepoint_clone_ptr(LDKDelayedPaymentBasepoint *NONNULL_PTR arg);
31861 export function DelayedPaymentBasepoint_clone_ptr(arg: bigint): bigint {
31862 if(!isWasmInitialized) {
31863 throw new Error("initializeWasm() must be awaited first!");
31865 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_clone_ptr(arg);
31866 return nativeResponseValue;
31868 // struct LDKDelayedPaymentBasepoint DelayedPaymentBasepoint_clone(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR orig);
31870 export function DelayedPaymentBasepoint_clone(orig: bigint): bigint {
31871 if(!isWasmInitialized) {
31872 throw new Error("initializeWasm() must be awaited first!");
31874 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_clone(orig);
31875 return nativeResponseValue;
31877 // uint64_t DelayedPaymentBasepoint_hash(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR o);
31879 export function DelayedPaymentBasepoint_hash(o: bigint): bigint {
31880 if(!isWasmInitialized) {
31881 throw new Error("initializeWasm() must be awaited first!");
31883 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_hash(o);
31884 return nativeResponseValue;
31886 // MUST_USE_RES struct LDKPublicKey DelayedPaymentBasepoint_to_public_key(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_arg);
31888 export function DelayedPaymentBasepoint_to_public_key(this_arg: bigint): number {
31889 if(!isWasmInitialized) {
31890 throw new Error("initializeWasm() must be awaited first!");
31892 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_to_public_key(this_arg);
31893 return nativeResponseValue;
31895 // struct LDKCVec_u8Z DelayedPaymentBasepoint_write(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR obj);
31897 export function DelayedPaymentBasepoint_write(obj: bigint): number {
31898 if(!isWasmInitialized) {
31899 throw new Error("initializeWasm() must be awaited first!");
31901 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_write(obj);
31902 return nativeResponseValue;
31904 // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ DelayedPaymentBasepoint_read(struct LDKu8slice ser);
31906 export function DelayedPaymentBasepoint_read(ser: number): bigint {
31907 if(!isWasmInitialized) {
31908 throw new Error("initializeWasm() must be awaited first!");
31910 const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_read(ser);
31911 return nativeResponseValue;
31913 // void DelayedPaymentKey_free(struct LDKDelayedPaymentKey this_obj);
31915 export function DelayedPaymentKey_free(this_obj: bigint): void {
31916 if(!isWasmInitialized) {
31917 throw new Error("initializeWasm() must be awaited first!");
31919 const nativeResponseValue = wasm.TS_DelayedPaymentKey_free(this_obj);
31920 // debug statements here
31922 // struct LDKPublicKey DelayedPaymentKey_get_a(const struct LDKDelayedPaymentKey *NONNULL_PTR this_ptr);
31924 export function DelayedPaymentKey_get_a(this_ptr: bigint): number {
31925 if(!isWasmInitialized) {
31926 throw new Error("initializeWasm() must be awaited first!");
31928 const nativeResponseValue = wasm.TS_DelayedPaymentKey_get_a(this_ptr);
31929 return nativeResponseValue;
31931 // void DelayedPaymentKey_set_a(struct LDKDelayedPaymentKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31933 export function DelayedPaymentKey_set_a(this_ptr: bigint, val: number): void {
31934 if(!isWasmInitialized) {
31935 throw new Error("initializeWasm() must be awaited first!");
31937 const nativeResponseValue = wasm.TS_DelayedPaymentKey_set_a(this_ptr, val);
31938 // debug statements here
31940 // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_new(struct LDKPublicKey a_arg);
31942 export function DelayedPaymentKey_new(a_arg: number): bigint {
31943 if(!isWasmInitialized) {
31944 throw new Error("initializeWasm() must be awaited first!");
31946 const nativeResponseValue = wasm.TS_DelayedPaymentKey_new(a_arg);
31947 return nativeResponseValue;
31949 // bool DelayedPaymentKey_eq(const struct LDKDelayedPaymentKey *NONNULL_PTR a, const struct LDKDelayedPaymentKey *NONNULL_PTR b);
31951 export function DelayedPaymentKey_eq(a: bigint, b: bigint): boolean {
31952 if(!isWasmInitialized) {
31953 throw new Error("initializeWasm() must be awaited first!");
31955 const nativeResponseValue = wasm.TS_DelayedPaymentKey_eq(a, b);
31956 return nativeResponseValue;
31958 // uint64_t DelayedPaymentKey_clone_ptr(LDKDelayedPaymentKey *NONNULL_PTR arg);
31960 export function DelayedPaymentKey_clone_ptr(arg: bigint): bigint {
31961 if(!isWasmInitialized) {
31962 throw new Error("initializeWasm() must be awaited first!");
31964 const nativeResponseValue = wasm.TS_DelayedPaymentKey_clone_ptr(arg);
31965 return nativeResponseValue;
31967 // struct LDKDelayedPaymentKey DelayedPaymentKey_clone(const struct LDKDelayedPaymentKey *NONNULL_PTR orig);
31969 export function DelayedPaymentKey_clone(orig: bigint): bigint {
31970 if(!isWasmInitialized) {
31971 throw new Error("initializeWasm() must be awaited first!");
31973 const nativeResponseValue = wasm.TS_DelayedPaymentKey_clone(orig);
31974 return nativeResponseValue;
31976 // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_from_basepoint(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
31978 export function DelayedPaymentKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
31979 if(!isWasmInitialized) {
31980 throw new Error("initializeWasm() must be awaited first!");
31982 const nativeResponseValue = wasm.TS_DelayedPaymentKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
31983 return nativeResponseValue;
31985 // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_from_secret_key(const uint8_t (*sk)[32]);
31987 export function DelayedPaymentKey_from_secret_key(sk: number): bigint {
31988 if(!isWasmInitialized) {
31989 throw new Error("initializeWasm() must be awaited first!");
31991 const nativeResponseValue = wasm.TS_DelayedPaymentKey_from_secret_key(sk);
31992 return nativeResponseValue;
31994 // MUST_USE_RES struct LDKPublicKey DelayedPaymentKey_to_public_key(const struct LDKDelayedPaymentKey *NONNULL_PTR this_arg);
31996 export function DelayedPaymentKey_to_public_key(this_arg: bigint): number {
31997 if(!isWasmInitialized) {
31998 throw new Error("initializeWasm() must be awaited first!");
32000 const nativeResponseValue = wasm.TS_DelayedPaymentKey_to_public_key(this_arg);
32001 return nativeResponseValue;
32003 // struct LDKCVec_u8Z DelayedPaymentKey_write(const struct LDKDelayedPaymentKey *NONNULL_PTR obj);
32005 export function DelayedPaymentKey_write(obj: bigint): number {
32006 if(!isWasmInitialized) {
32007 throw new Error("initializeWasm() must be awaited first!");
32009 const nativeResponseValue = wasm.TS_DelayedPaymentKey_write(obj);
32010 return nativeResponseValue;
32012 // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ DelayedPaymentKey_read(struct LDKu8slice ser);
32014 export function DelayedPaymentKey_read(ser: number): bigint {
32015 if(!isWasmInitialized) {
32016 throw new Error("initializeWasm() must be awaited first!");
32018 const nativeResponseValue = wasm.TS_DelayedPaymentKey_read(ser);
32019 return nativeResponseValue;
32021 // void HtlcBasepoint_free(struct LDKHtlcBasepoint this_obj);
32023 export function HtlcBasepoint_free(this_obj: bigint): void {
32024 if(!isWasmInitialized) {
32025 throw new Error("initializeWasm() must be awaited first!");
32027 const nativeResponseValue = wasm.TS_HtlcBasepoint_free(this_obj);
32028 // debug statements here
32030 // struct LDKPublicKey HtlcBasepoint_get_a(const struct LDKHtlcBasepoint *NONNULL_PTR this_ptr);
32032 export function HtlcBasepoint_get_a(this_ptr: bigint): number {
32033 if(!isWasmInitialized) {
32034 throw new Error("initializeWasm() must be awaited first!");
32036 const nativeResponseValue = wasm.TS_HtlcBasepoint_get_a(this_ptr);
32037 return nativeResponseValue;
32039 // void HtlcBasepoint_set_a(struct LDKHtlcBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32041 export function HtlcBasepoint_set_a(this_ptr: bigint, val: number): void {
32042 if(!isWasmInitialized) {
32043 throw new Error("initializeWasm() must be awaited first!");
32045 const nativeResponseValue = wasm.TS_HtlcBasepoint_set_a(this_ptr, val);
32046 // debug statements here
32048 // MUST_USE_RES struct LDKHtlcBasepoint HtlcBasepoint_new(struct LDKPublicKey a_arg);
32050 export function HtlcBasepoint_new(a_arg: number): bigint {
32051 if(!isWasmInitialized) {
32052 throw new Error("initializeWasm() must be awaited first!");
32054 const nativeResponseValue = wasm.TS_HtlcBasepoint_new(a_arg);
32055 return nativeResponseValue;
32057 // bool HtlcBasepoint_eq(const struct LDKHtlcBasepoint *NONNULL_PTR a, const struct LDKHtlcBasepoint *NONNULL_PTR b);
32059 export function HtlcBasepoint_eq(a: bigint, b: bigint): boolean {
32060 if(!isWasmInitialized) {
32061 throw new Error("initializeWasm() must be awaited first!");
32063 const nativeResponseValue = wasm.TS_HtlcBasepoint_eq(a, b);
32064 return nativeResponseValue;
32066 // uint64_t HtlcBasepoint_clone_ptr(LDKHtlcBasepoint *NONNULL_PTR arg);
32068 export function HtlcBasepoint_clone_ptr(arg: bigint): bigint {
32069 if(!isWasmInitialized) {
32070 throw new Error("initializeWasm() must be awaited first!");
32072 const nativeResponseValue = wasm.TS_HtlcBasepoint_clone_ptr(arg);
32073 return nativeResponseValue;
32075 // struct LDKHtlcBasepoint HtlcBasepoint_clone(const struct LDKHtlcBasepoint *NONNULL_PTR orig);
32077 export function HtlcBasepoint_clone(orig: bigint): bigint {
32078 if(!isWasmInitialized) {
32079 throw new Error("initializeWasm() must be awaited first!");
32081 const nativeResponseValue = wasm.TS_HtlcBasepoint_clone(orig);
32082 return nativeResponseValue;
32084 // uint64_t HtlcBasepoint_hash(const struct LDKHtlcBasepoint *NONNULL_PTR o);
32086 export function HtlcBasepoint_hash(o: bigint): bigint {
32087 if(!isWasmInitialized) {
32088 throw new Error("initializeWasm() must be awaited first!");
32090 const nativeResponseValue = wasm.TS_HtlcBasepoint_hash(o);
32091 return nativeResponseValue;
32093 // MUST_USE_RES struct LDKPublicKey HtlcBasepoint_to_public_key(const struct LDKHtlcBasepoint *NONNULL_PTR this_arg);
32095 export function HtlcBasepoint_to_public_key(this_arg: bigint): number {
32096 if(!isWasmInitialized) {
32097 throw new Error("initializeWasm() must be awaited first!");
32099 const nativeResponseValue = wasm.TS_HtlcBasepoint_to_public_key(this_arg);
32100 return nativeResponseValue;
32102 // struct LDKCVec_u8Z HtlcBasepoint_write(const struct LDKHtlcBasepoint *NONNULL_PTR obj);
32104 export function HtlcBasepoint_write(obj: bigint): number {
32105 if(!isWasmInitialized) {
32106 throw new Error("initializeWasm() must be awaited first!");
32108 const nativeResponseValue = wasm.TS_HtlcBasepoint_write(obj);
32109 return nativeResponseValue;
32111 // struct LDKCResult_HtlcBasepointDecodeErrorZ HtlcBasepoint_read(struct LDKu8slice ser);
32113 export function HtlcBasepoint_read(ser: number): bigint {
32114 if(!isWasmInitialized) {
32115 throw new Error("initializeWasm() must be awaited first!");
32117 const nativeResponseValue = wasm.TS_HtlcBasepoint_read(ser);
32118 return nativeResponseValue;
32120 // void HtlcKey_free(struct LDKHtlcKey this_obj);
32122 export function HtlcKey_free(this_obj: bigint): void {
32123 if(!isWasmInitialized) {
32124 throw new Error("initializeWasm() must be awaited first!");
32126 const nativeResponseValue = wasm.TS_HtlcKey_free(this_obj);
32127 // debug statements here
32129 // struct LDKPublicKey HtlcKey_get_a(const struct LDKHtlcKey *NONNULL_PTR this_ptr);
32131 export function HtlcKey_get_a(this_ptr: bigint): number {
32132 if(!isWasmInitialized) {
32133 throw new Error("initializeWasm() must be awaited first!");
32135 const nativeResponseValue = wasm.TS_HtlcKey_get_a(this_ptr);
32136 return nativeResponseValue;
32138 // void HtlcKey_set_a(struct LDKHtlcKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32140 export function HtlcKey_set_a(this_ptr: bigint, val: number): void {
32141 if(!isWasmInitialized) {
32142 throw new Error("initializeWasm() must be awaited first!");
32144 const nativeResponseValue = wasm.TS_HtlcKey_set_a(this_ptr, val);
32145 // debug statements here
32147 // MUST_USE_RES struct LDKHtlcKey HtlcKey_new(struct LDKPublicKey a_arg);
32149 export function HtlcKey_new(a_arg: number): bigint {
32150 if(!isWasmInitialized) {
32151 throw new Error("initializeWasm() must be awaited first!");
32153 const nativeResponseValue = wasm.TS_HtlcKey_new(a_arg);
32154 return nativeResponseValue;
32156 // bool HtlcKey_eq(const struct LDKHtlcKey *NONNULL_PTR a, const struct LDKHtlcKey *NONNULL_PTR b);
32158 export function HtlcKey_eq(a: bigint, b: bigint): boolean {
32159 if(!isWasmInitialized) {
32160 throw new Error("initializeWasm() must be awaited first!");
32162 const nativeResponseValue = wasm.TS_HtlcKey_eq(a, b);
32163 return nativeResponseValue;
32165 // uint64_t HtlcKey_clone_ptr(LDKHtlcKey *NONNULL_PTR arg);
32167 export function HtlcKey_clone_ptr(arg: bigint): bigint {
32168 if(!isWasmInitialized) {
32169 throw new Error("initializeWasm() must be awaited first!");
32171 const nativeResponseValue = wasm.TS_HtlcKey_clone_ptr(arg);
32172 return nativeResponseValue;
32174 // struct LDKHtlcKey HtlcKey_clone(const struct LDKHtlcKey *NONNULL_PTR orig);
32176 export function HtlcKey_clone(orig: bigint): bigint {
32177 if(!isWasmInitialized) {
32178 throw new Error("initializeWasm() must be awaited first!");
32180 const nativeResponseValue = wasm.TS_HtlcKey_clone(orig);
32181 return nativeResponseValue;
32183 // MUST_USE_RES struct LDKHtlcKey HtlcKey_from_basepoint(const struct LDKHtlcBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
32185 export function HtlcKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
32186 if(!isWasmInitialized) {
32187 throw new Error("initializeWasm() must be awaited first!");
32189 const nativeResponseValue = wasm.TS_HtlcKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
32190 return nativeResponseValue;
32192 // MUST_USE_RES struct LDKHtlcKey HtlcKey_from_secret_key(const uint8_t (*sk)[32]);
32194 export function HtlcKey_from_secret_key(sk: number): bigint {
32195 if(!isWasmInitialized) {
32196 throw new Error("initializeWasm() must be awaited first!");
32198 const nativeResponseValue = wasm.TS_HtlcKey_from_secret_key(sk);
32199 return nativeResponseValue;
32201 // MUST_USE_RES struct LDKPublicKey HtlcKey_to_public_key(const struct LDKHtlcKey *NONNULL_PTR this_arg);
32203 export function HtlcKey_to_public_key(this_arg: bigint): number {
32204 if(!isWasmInitialized) {
32205 throw new Error("initializeWasm() must be awaited first!");
32207 const nativeResponseValue = wasm.TS_HtlcKey_to_public_key(this_arg);
32208 return nativeResponseValue;
32210 // struct LDKCVec_u8Z HtlcKey_write(const struct LDKHtlcKey *NONNULL_PTR obj);
32212 export function HtlcKey_write(obj: bigint): number {
32213 if(!isWasmInitialized) {
32214 throw new Error("initializeWasm() must be awaited first!");
32216 const nativeResponseValue = wasm.TS_HtlcKey_write(obj);
32217 return nativeResponseValue;
32219 // struct LDKCResult_HtlcKeyDecodeErrorZ HtlcKey_read(struct LDKu8slice ser);
32221 export function HtlcKey_read(ser: number): bigint {
32222 if(!isWasmInitialized) {
32223 throw new Error("initializeWasm() must be awaited first!");
32225 const nativeResponseValue = wasm.TS_HtlcKey_read(ser);
32226 return nativeResponseValue;
32228 // void RevocationBasepoint_free(struct LDKRevocationBasepoint this_obj);
32230 export function RevocationBasepoint_free(this_obj: bigint): void {
32231 if(!isWasmInitialized) {
32232 throw new Error("initializeWasm() must be awaited first!");
32234 const nativeResponseValue = wasm.TS_RevocationBasepoint_free(this_obj);
32235 // debug statements here
32237 // struct LDKPublicKey RevocationBasepoint_get_a(const struct LDKRevocationBasepoint *NONNULL_PTR this_ptr);
32239 export function RevocationBasepoint_get_a(this_ptr: bigint): number {
32240 if(!isWasmInitialized) {
32241 throw new Error("initializeWasm() must be awaited first!");
32243 const nativeResponseValue = wasm.TS_RevocationBasepoint_get_a(this_ptr);
32244 return nativeResponseValue;
32246 // void RevocationBasepoint_set_a(struct LDKRevocationBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32248 export function RevocationBasepoint_set_a(this_ptr: bigint, val: number): void {
32249 if(!isWasmInitialized) {
32250 throw new Error("initializeWasm() must be awaited first!");
32252 const nativeResponseValue = wasm.TS_RevocationBasepoint_set_a(this_ptr, val);
32253 // debug statements here
32255 // MUST_USE_RES struct LDKRevocationBasepoint RevocationBasepoint_new(struct LDKPublicKey a_arg);
32257 export function RevocationBasepoint_new(a_arg: number): bigint {
32258 if(!isWasmInitialized) {
32259 throw new Error("initializeWasm() must be awaited first!");
32261 const nativeResponseValue = wasm.TS_RevocationBasepoint_new(a_arg);
32262 return nativeResponseValue;
32264 // bool RevocationBasepoint_eq(const struct LDKRevocationBasepoint *NONNULL_PTR a, const struct LDKRevocationBasepoint *NONNULL_PTR b);
32266 export function RevocationBasepoint_eq(a: bigint, b: bigint): boolean {
32267 if(!isWasmInitialized) {
32268 throw new Error("initializeWasm() must be awaited first!");
32270 const nativeResponseValue = wasm.TS_RevocationBasepoint_eq(a, b);
32271 return nativeResponseValue;
32273 // uint64_t RevocationBasepoint_clone_ptr(LDKRevocationBasepoint *NONNULL_PTR arg);
32275 export function RevocationBasepoint_clone_ptr(arg: bigint): bigint {
32276 if(!isWasmInitialized) {
32277 throw new Error("initializeWasm() must be awaited first!");
32279 const nativeResponseValue = wasm.TS_RevocationBasepoint_clone_ptr(arg);
32280 return nativeResponseValue;
32282 // struct LDKRevocationBasepoint RevocationBasepoint_clone(const struct LDKRevocationBasepoint *NONNULL_PTR orig);
32284 export function RevocationBasepoint_clone(orig: bigint): bigint {
32285 if(!isWasmInitialized) {
32286 throw new Error("initializeWasm() must be awaited first!");
32288 const nativeResponseValue = wasm.TS_RevocationBasepoint_clone(orig);
32289 return nativeResponseValue;
32291 // uint64_t RevocationBasepoint_hash(const struct LDKRevocationBasepoint *NONNULL_PTR o);
32293 export function RevocationBasepoint_hash(o: bigint): bigint {
32294 if(!isWasmInitialized) {
32295 throw new Error("initializeWasm() must be awaited first!");
32297 const nativeResponseValue = wasm.TS_RevocationBasepoint_hash(o);
32298 return nativeResponseValue;
32300 // MUST_USE_RES struct LDKPublicKey RevocationBasepoint_to_public_key(const struct LDKRevocationBasepoint *NONNULL_PTR this_arg);
32302 export function RevocationBasepoint_to_public_key(this_arg: bigint): number {
32303 if(!isWasmInitialized) {
32304 throw new Error("initializeWasm() must be awaited first!");
32306 const nativeResponseValue = wasm.TS_RevocationBasepoint_to_public_key(this_arg);
32307 return nativeResponseValue;
32309 // struct LDKCVec_u8Z RevocationBasepoint_write(const struct LDKRevocationBasepoint *NONNULL_PTR obj);
32311 export function RevocationBasepoint_write(obj: bigint): number {
32312 if(!isWasmInitialized) {
32313 throw new Error("initializeWasm() must be awaited first!");
32315 const nativeResponseValue = wasm.TS_RevocationBasepoint_write(obj);
32316 return nativeResponseValue;
32318 // struct LDKCResult_RevocationBasepointDecodeErrorZ RevocationBasepoint_read(struct LDKu8slice ser);
32320 export function RevocationBasepoint_read(ser: number): bigint {
32321 if(!isWasmInitialized) {
32322 throw new Error("initializeWasm() must be awaited first!");
32324 const nativeResponseValue = wasm.TS_RevocationBasepoint_read(ser);
32325 return nativeResponseValue;
32327 // void RevocationKey_free(struct LDKRevocationKey this_obj);
32329 export function RevocationKey_free(this_obj: bigint): void {
32330 if(!isWasmInitialized) {
32331 throw new Error("initializeWasm() must be awaited first!");
32333 const nativeResponseValue = wasm.TS_RevocationKey_free(this_obj);
32334 // debug statements here
32336 // struct LDKPublicKey RevocationKey_get_a(const struct LDKRevocationKey *NONNULL_PTR this_ptr);
32338 export function RevocationKey_get_a(this_ptr: bigint): number {
32339 if(!isWasmInitialized) {
32340 throw new Error("initializeWasm() must be awaited first!");
32342 const nativeResponseValue = wasm.TS_RevocationKey_get_a(this_ptr);
32343 return nativeResponseValue;
32345 // void RevocationKey_set_a(struct LDKRevocationKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32347 export function RevocationKey_set_a(this_ptr: bigint, val: number): void {
32348 if(!isWasmInitialized) {
32349 throw new Error("initializeWasm() must be awaited first!");
32351 const nativeResponseValue = wasm.TS_RevocationKey_set_a(this_ptr, val);
32352 // debug statements here
32354 // MUST_USE_RES struct LDKRevocationKey RevocationKey_new(struct LDKPublicKey a_arg);
32356 export function RevocationKey_new(a_arg: number): bigint {
32357 if(!isWasmInitialized) {
32358 throw new Error("initializeWasm() must be awaited first!");
32360 const nativeResponseValue = wasm.TS_RevocationKey_new(a_arg);
32361 return nativeResponseValue;
32363 // bool RevocationKey_eq(const struct LDKRevocationKey *NONNULL_PTR a, const struct LDKRevocationKey *NONNULL_PTR b);
32365 export function RevocationKey_eq(a: bigint, b: bigint): boolean {
32366 if(!isWasmInitialized) {
32367 throw new Error("initializeWasm() must be awaited first!");
32369 const nativeResponseValue = wasm.TS_RevocationKey_eq(a, b);
32370 return nativeResponseValue;
32372 // uint64_t RevocationKey_clone_ptr(LDKRevocationKey *NONNULL_PTR arg);
32374 export function RevocationKey_clone_ptr(arg: bigint): bigint {
32375 if(!isWasmInitialized) {
32376 throw new Error("initializeWasm() must be awaited first!");
32378 const nativeResponseValue = wasm.TS_RevocationKey_clone_ptr(arg);
32379 return nativeResponseValue;
32381 // struct LDKRevocationKey RevocationKey_clone(const struct LDKRevocationKey *NONNULL_PTR orig);
32383 export function RevocationKey_clone(orig: bigint): bigint {
32384 if(!isWasmInitialized) {
32385 throw new Error("initializeWasm() must be awaited first!");
32387 const nativeResponseValue = wasm.TS_RevocationKey_clone(orig);
32388 return nativeResponseValue;
32390 // uint64_t RevocationKey_hash(const struct LDKRevocationKey *NONNULL_PTR o);
32392 export function RevocationKey_hash(o: bigint): bigint {
32393 if(!isWasmInitialized) {
32394 throw new Error("initializeWasm() must be awaited first!");
32396 const nativeResponseValue = wasm.TS_RevocationKey_hash(o);
32397 return nativeResponseValue;
32399 // MUST_USE_RES struct LDKRevocationKey RevocationKey_from_basepoint(const struct LDKRevocationBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
32401 export function RevocationKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
32402 if(!isWasmInitialized) {
32403 throw new Error("initializeWasm() must be awaited first!");
32405 const nativeResponseValue = wasm.TS_RevocationKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
32406 return nativeResponseValue;
32408 // MUST_USE_RES struct LDKPublicKey RevocationKey_to_public_key(const struct LDKRevocationKey *NONNULL_PTR this_arg);
32410 export function RevocationKey_to_public_key(this_arg: bigint): number {
32411 if(!isWasmInitialized) {
32412 throw new Error("initializeWasm() must be awaited first!");
32414 const nativeResponseValue = wasm.TS_RevocationKey_to_public_key(this_arg);
32415 return nativeResponseValue;
32417 // struct LDKCVec_u8Z RevocationKey_write(const struct LDKRevocationKey *NONNULL_PTR obj);
32419 export function RevocationKey_write(obj: bigint): number {
32420 if(!isWasmInitialized) {
32421 throw new Error("initializeWasm() must be awaited first!");
32423 const nativeResponseValue = wasm.TS_RevocationKey_write(obj);
32424 return nativeResponseValue;
32426 // struct LDKCResult_RevocationKeyDecodeErrorZ RevocationKey_read(struct LDKu8slice ser);
32428 export function RevocationKey_read(ser: number): bigint {
32429 if(!isWasmInitialized) {
32430 throw new Error("initializeWasm() must be awaited first!");
32432 const nativeResponseValue = wasm.TS_RevocationKey_read(ser);
32433 return nativeResponseValue;
32435 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
32437 export function ExpandedKey_free(this_obj: bigint): void {
32438 if(!isWasmInitialized) {
32439 throw new Error("initializeWasm() must be awaited first!");
32441 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
32442 // debug statements here
32444 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
32446 export function ExpandedKey_new(key_material: number): bigint {
32447 if(!isWasmInitialized) {
32448 throw new Error("initializeWasm() must be awaited first!");
32450 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
32451 return nativeResponseValue;
32453 // 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);
32455 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 {
32456 if(!isWasmInitialized) {
32457 throw new Error("initializeWasm() must be awaited first!");
32459 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, entropy_source, current_time, min_final_cltv_expiry_delta);
32460 return nativeResponseValue;
32462 // 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);
32464 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 {
32465 if(!isWasmInitialized) {
32466 throw new Error("initializeWasm() must be awaited first!");
32468 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time, min_final_cltv_expiry_delta);
32469 return nativeResponseValue;
32471 // void DecodeError_free(struct LDKDecodeError this_ptr);
32473 export function DecodeError_free(this_ptr: bigint): void {
32474 if(!isWasmInitialized) {
32475 throw new Error("initializeWasm() must be awaited first!");
32477 const nativeResponseValue = wasm.TS_DecodeError_free(this_ptr);
32478 // debug statements here
32480 // uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
32482 export function DecodeError_clone_ptr(arg: bigint): bigint {
32483 if(!isWasmInitialized) {
32484 throw new Error("initializeWasm() must be awaited first!");
32486 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
32487 return nativeResponseValue;
32489 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
32491 export function DecodeError_clone(orig: bigint): bigint {
32492 if(!isWasmInitialized) {
32493 throw new Error("initializeWasm() must be awaited first!");
32495 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
32496 return nativeResponseValue;
32498 // struct LDKDecodeError DecodeError_unknown_version(void);
32500 export function DecodeError_unknown_version(): bigint {
32501 if(!isWasmInitialized) {
32502 throw new Error("initializeWasm() must be awaited first!");
32504 const nativeResponseValue = wasm.TS_DecodeError_unknown_version();
32505 return nativeResponseValue;
32507 // struct LDKDecodeError DecodeError_unknown_required_feature(void);
32509 export function DecodeError_unknown_required_feature(): bigint {
32510 if(!isWasmInitialized) {
32511 throw new Error("initializeWasm() must be awaited first!");
32513 const nativeResponseValue = wasm.TS_DecodeError_unknown_required_feature();
32514 return nativeResponseValue;
32516 // struct LDKDecodeError DecodeError_invalid_value(void);
32518 export function DecodeError_invalid_value(): bigint {
32519 if(!isWasmInitialized) {
32520 throw new Error("initializeWasm() must be awaited first!");
32522 const nativeResponseValue = wasm.TS_DecodeError_invalid_value();
32523 return nativeResponseValue;
32525 // struct LDKDecodeError DecodeError_short_read(void);
32527 export function DecodeError_short_read(): bigint {
32528 if(!isWasmInitialized) {
32529 throw new Error("initializeWasm() must be awaited first!");
32531 const nativeResponseValue = wasm.TS_DecodeError_short_read();
32532 return nativeResponseValue;
32534 // struct LDKDecodeError DecodeError_bad_length_descriptor(void);
32536 export function DecodeError_bad_length_descriptor(): bigint {
32537 if(!isWasmInitialized) {
32538 throw new Error("initializeWasm() must be awaited first!");
32540 const nativeResponseValue = wasm.TS_DecodeError_bad_length_descriptor();
32541 return nativeResponseValue;
32543 // struct LDKDecodeError DecodeError_io(enum LDKIOError a);
32545 export function DecodeError_io(a: IOError): bigint {
32546 if(!isWasmInitialized) {
32547 throw new Error("initializeWasm() must be awaited first!");
32549 const nativeResponseValue = wasm.TS_DecodeError_io(a);
32550 return nativeResponseValue;
32552 // struct LDKDecodeError DecodeError_unsupported_compression(void);
32554 export function DecodeError_unsupported_compression(): bigint {
32555 if(!isWasmInitialized) {
32556 throw new Error("initializeWasm() must be awaited first!");
32558 const nativeResponseValue = wasm.TS_DecodeError_unsupported_compression();
32559 return nativeResponseValue;
32561 // uint64_t DecodeError_hash(const struct LDKDecodeError *NONNULL_PTR o);
32563 export function DecodeError_hash(o: bigint): bigint {
32564 if(!isWasmInitialized) {
32565 throw new Error("initializeWasm() must be awaited first!");
32567 const nativeResponseValue = wasm.TS_DecodeError_hash(o);
32568 return nativeResponseValue;
32570 // bool DecodeError_eq(const struct LDKDecodeError *NONNULL_PTR a, const struct LDKDecodeError *NONNULL_PTR b);
32572 export function DecodeError_eq(a: bigint, b: bigint): boolean {
32573 if(!isWasmInitialized) {
32574 throw new Error("initializeWasm() must be awaited first!");
32576 const nativeResponseValue = wasm.TS_DecodeError_eq(a, b);
32577 return nativeResponseValue;
32579 // void Init_free(struct LDKInit this_obj);
32581 export function Init_free(this_obj: bigint): void {
32582 if(!isWasmInitialized) {
32583 throw new Error("initializeWasm() must be awaited first!");
32585 const nativeResponseValue = wasm.TS_Init_free(this_obj);
32586 // debug statements here
32588 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
32590 export function Init_get_features(this_ptr: bigint): bigint {
32591 if(!isWasmInitialized) {
32592 throw new Error("initializeWasm() must be awaited first!");
32594 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
32595 return nativeResponseValue;
32597 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
32599 export function Init_set_features(this_ptr: bigint, val: bigint): void {
32600 if(!isWasmInitialized) {
32601 throw new Error("initializeWasm() must be awaited first!");
32603 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
32604 // debug statements here
32606 // struct LDKCOption_CVec_ThirtyTwoBytesZZ Init_get_networks(const struct LDKInit *NONNULL_PTR this_ptr);
32608 export function Init_get_networks(this_ptr: bigint): bigint {
32609 if(!isWasmInitialized) {
32610 throw new Error("initializeWasm() must be awaited first!");
32612 const nativeResponseValue = wasm.TS_Init_get_networks(this_ptr);
32613 return nativeResponseValue;
32615 // void Init_set_networks(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_CVec_ThirtyTwoBytesZZ val);
32617 export function Init_set_networks(this_ptr: bigint, val: bigint): void {
32618 if(!isWasmInitialized) {
32619 throw new Error("initializeWasm() must be awaited first!");
32621 const nativeResponseValue = wasm.TS_Init_set_networks(this_ptr, val);
32622 // debug statements here
32624 // struct LDKCOption_SocketAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
32626 export function Init_get_remote_network_address(this_ptr: bigint): bigint {
32627 if(!isWasmInitialized) {
32628 throw new Error("initializeWasm() must be awaited first!");
32630 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
32631 return nativeResponseValue;
32633 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_SocketAddressZ val);
32635 export function Init_set_remote_network_address(this_ptr: bigint, val: bigint): void {
32636 if(!isWasmInitialized) {
32637 throw new Error("initializeWasm() must be awaited first!");
32639 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
32640 // debug statements here
32642 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_CVec_ThirtyTwoBytesZZ networks_arg, struct LDKCOption_SocketAddressZ remote_network_address_arg);
32644 export function Init_new(features_arg: bigint, networks_arg: bigint, remote_network_address_arg: bigint): bigint {
32645 if(!isWasmInitialized) {
32646 throw new Error("initializeWasm() must be awaited first!");
32648 const nativeResponseValue = wasm.TS_Init_new(features_arg, networks_arg, remote_network_address_arg);
32649 return nativeResponseValue;
32651 // uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
32653 export function Init_clone_ptr(arg: bigint): bigint {
32654 if(!isWasmInitialized) {
32655 throw new Error("initializeWasm() must be awaited first!");
32657 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
32658 return nativeResponseValue;
32660 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
32662 export function Init_clone(orig: bigint): bigint {
32663 if(!isWasmInitialized) {
32664 throw new Error("initializeWasm() must be awaited first!");
32666 const nativeResponseValue = wasm.TS_Init_clone(orig);
32667 return nativeResponseValue;
32669 // uint64_t Init_hash(const struct LDKInit *NONNULL_PTR o);
32671 export function Init_hash(o: bigint): bigint {
32672 if(!isWasmInitialized) {
32673 throw new Error("initializeWasm() must be awaited first!");
32675 const nativeResponseValue = wasm.TS_Init_hash(o);
32676 return nativeResponseValue;
32678 // bool Init_eq(const struct LDKInit *NONNULL_PTR a, const struct LDKInit *NONNULL_PTR b);
32680 export function Init_eq(a: bigint, b: bigint): boolean {
32681 if(!isWasmInitialized) {
32682 throw new Error("initializeWasm() must be awaited first!");
32684 const nativeResponseValue = wasm.TS_Init_eq(a, b);
32685 return nativeResponseValue;
32687 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
32689 export function ErrorMessage_free(this_obj: bigint): void {
32690 if(!isWasmInitialized) {
32691 throw new Error("initializeWasm() must be awaited first!");
32693 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
32694 // debug statements here
32696 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
32698 export function ErrorMessage_get_channel_id(this_ptr: bigint): number {
32699 if(!isWasmInitialized) {
32700 throw new Error("initializeWasm() must be awaited first!");
32702 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
32703 return nativeResponseValue;
32705 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32707 export function ErrorMessage_set_channel_id(this_ptr: bigint, val: number): void {
32708 if(!isWasmInitialized) {
32709 throw new Error("initializeWasm() must be awaited first!");
32711 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
32712 // debug statements here
32714 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
32716 export function ErrorMessage_get_data(this_ptr: bigint): number {
32717 if(!isWasmInitialized) {
32718 throw new Error("initializeWasm() must be awaited first!");
32720 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
32721 return nativeResponseValue;
32723 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
32725 export function ErrorMessage_set_data(this_ptr: bigint, val: number): void {
32726 if(!isWasmInitialized) {
32727 throw new Error("initializeWasm() must be awaited first!");
32729 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
32730 // debug statements here
32732 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
32734 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): bigint {
32735 if(!isWasmInitialized) {
32736 throw new Error("initializeWasm() must be awaited first!");
32738 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
32739 return nativeResponseValue;
32741 // uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
32743 export function ErrorMessage_clone_ptr(arg: bigint): bigint {
32744 if(!isWasmInitialized) {
32745 throw new Error("initializeWasm() must be awaited first!");
32747 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
32748 return nativeResponseValue;
32750 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
32752 export function ErrorMessage_clone(orig: bigint): bigint {
32753 if(!isWasmInitialized) {
32754 throw new Error("initializeWasm() must be awaited first!");
32756 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
32757 return nativeResponseValue;
32759 // uint64_t ErrorMessage_hash(const struct LDKErrorMessage *NONNULL_PTR o);
32761 export function ErrorMessage_hash(o: bigint): bigint {
32762 if(!isWasmInitialized) {
32763 throw new Error("initializeWasm() must be awaited first!");
32765 const nativeResponseValue = wasm.TS_ErrorMessage_hash(o);
32766 return nativeResponseValue;
32768 // bool ErrorMessage_eq(const struct LDKErrorMessage *NONNULL_PTR a, const struct LDKErrorMessage *NONNULL_PTR b);
32770 export function ErrorMessage_eq(a: bigint, b: bigint): boolean {
32771 if(!isWasmInitialized) {
32772 throw new Error("initializeWasm() must be awaited first!");
32774 const nativeResponseValue = wasm.TS_ErrorMessage_eq(a, b);
32775 return nativeResponseValue;
32777 // void WarningMessage_free(struct LDKWarningMessage this_obj);
32779 export function WarningMessage_free(this_obj: bigint): void {
32780 if(!isWasmInitialized) {
32781 throw new Error("initializeWasm() must be awaited first!");
32783 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
32784 // debug statements here
32786 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
32788 export function WarningMessage_get_channel_id(this_ptr: bigint): number {
32789 if(!isWasmInitialized) {
32790 throw new Error("initializeWasm() must be awaited first!");
32792 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
32793 return nativeResponseValue;
32795 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
32797 export function WarningMessage_set_channel_id(this_ptr: bigint, val: number): void {
32798 if(!isWasmInitialized) {
32799 throw new Error("initializeWasm() must be awaited first!");
32801 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
32802 // debug statements here
32804 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
32806 export function WarningMessage_get_data(this_ptr: bigint): number {
32807 if(!isWasmInitialized) {
32808 throw new Error("initializeWasm() must be awaited first!");
32810 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
32811 return nativeResponseValue;
32813 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
32815 export function WarningMessage_set_data(this_ptr: bigint, val: number): void {
32816 if(!isWasmInitialized) {
32817 throw new Error("initializeWasm() must be awaited first!");
32819 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
32820 // debug statements here
32822 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
32824 export function WarningMessage_new(channel_id_arg: number, data_arg: number): bigint {
32825 if(!isWasmInitialized) {
32826 throw new Error("initializeWasm() must be awaited first!");
32828 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
32829 return nativeResponseValue;
32831 // uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
32833 export function WarningMessage_clone_ptr(arg: bigint): bigint {
32834 if(!isWasmInitialized) {
32835 throw new Error("initializeWasm() must be awaited first!");
32837 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
32838 return nativeResponseValue;
32840 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
32842 export function WarningMessage_clone(orig: bigint): bigint {
32843 if(!isWasmInitialized) {
32844 throw new Error("initializeWasm() must be awaited first!");
32846 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
32847 return nativeResponseValue;
32849 // uint64_t WarningMessage_hash(const struct LDKWarningMessage *NONNULL_PTR o);
32851 export function WarningMessage_hash(o: bigint): bigint {
32852 if(!isWasmInitialized) {
32853 throw new Error("initializeWasm() must be awaited first!");
32855 const nativeResponseValue = wasm.TS_WarningMessage_hash(o);
32856 return nativeResponseValue;
32858 // bool WarningMessage_eq(const struct LDKWarningMessage *NONNULL_PTR a, const struct LDKWarningMessage *NONNULL_PTR b);
32860 export function WarningMessage_eq(a: bigint, b: bigint): boolean {
32861 if(!isWasmInitialized) {
32862 throw new Error("initializeWasm() must be awaited first!");
32864 const nativeResponseValue = wasm.TS_WarningMessage_eq(a, b);
32865 return nativeResponseValue;
32867 // void Ping_free(struct LDKPing this_obj);
32869 export function Ping_free(this_obj: bigint): void {
32870 if(!isWasmInitialized) {
32871 throw new Error("initializeWasm() must be awaited first!");
32873 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
32874 // debug statements here
32876 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
32878 export function Ping_get_ponglen(this_ptr: bigint): number {
32879 if(!isWasmInitialized) {
32880 throw new Error("initializeWasm() must be awaited first!");
32882 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
32883 return nativeResponseValue;
32885 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
32887 export function Ping_set_ponglen(this_ptr: bigint, val: number): void {
32888 if(!isWasmInitialized) {
32889 throw new Error("initializeWasm() must be awaited first!");
32891 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
32892 // debug statements here
32894 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
32896 export function Ping_get_byteslen(this_ptr: bigint): number {
32897 if(!isWasmInitialized) {
32898 throw new Error("initializeWasm() must be awaited first!");
32900 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
32901 return nativeResponseValue;
32903 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
32905 export function Ping_set_byteslen(this_ptr: bigint, val: number): void {
32906 if(!isWasmInitialized) {
32907 throw new Error("initializeWasm() must be awaited first!");
32909 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
32910 // debug statements here
32912 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
32914 export function Ping_new(ponglen_arg: number, byteslen_arg: number): bigint {
32915 if(!isWasmInitialized) {
32916 throw new Error("initializeWasm() must be awaited first!");
32918 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
32919 return nativeResponseValue;
32921 // uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
32923 export function Ping_clone_ptr(arg: bigint): bigint {
32924 if(!isWasmInitialized) {
32925 throw new Error("initializeWasm() must be awaited first!");
32927 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
32928 return nativeResponseValue;
32930 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
32932 export function Ping_clone(orig: bigint): bigint {
32933 if(!isWasmInitialized) {
32934 throw new Error("initializeWasm() must be awaited first!");
32936 const nativeResponseValue = wasm.TS_Ping_clone(orig);
32937 return nativeResponseValue;
32939 // uint64_t Ping_hash(const struct LDKPing *NONNULL_PTR o);
32941 export function Ping_hash(o: bigint): bigint {
32942 if(!isWasmInitialized) {
32943 throw new Error("initializeWasm() must be awaited first!");
32945 const nativeResponseValue = wasm.TS_Ping_hash(o);
32946 return nativeResponseValue;
32948 // bool Ping_eq(const struct LDKPing *NONNULL_PTR a, const struct LDKPing *NONNULL_PTR b);
32950 export function Ping_eq(a: bigint, b: bigint): boolean {
32951 if(!isWasmInitialized) {
32952 throw new Error("initializeWasm() must be awaited first!");
32954 const nativeResponseValue = wasm.TS_Ping_eq(a, b);
32955 return nativeResponseValue;
32957 // void Pong_free(struct LDKPong this_obj);
32959 export function Pong_free(this_obj: bigint): void {
32960 if(!isWasmInitialized) {
32961 throw new Error("initializeWasm() must be awaited first!");
32963 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
32964 // debug statements here
32966 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
32968 export function Pong_get_byteslen(this_ptr: bigint): number {
32969 if(!isWasmInitialized) {
32970 throw new Error("initializeWasm() must be awaited first!");
32972 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
32973 return nativeResponseValue;
32975 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
32977 export function Pong_set_byteslen(this_ptr: bigint, val: number): void {
32978 if(!isWasmInitialized) {
32979 throw new Error("initializeWasm() must be awaited first!");
32981 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
32982 // debug statements here
32984 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
32986 export function Pong_new(byteslen_arg: number): bigint {
32987 if(!isWasmInitialized) {
32988 throw new Error("initializeWasm() must be awaited first!");
32990 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
32991 return nativeResponseValue;
32993 // uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
32995 export function Pong_clone_ptr(arg: bigint): bigint {
32996 if(!isWasmInitialized) {
32997 throw new Error("initializeWasm() must be awaited first!");
32999 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
33000 return nativeResponseValue;
33002 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
33004 export function Pong_clone(orig: bigint): bigint {
33005 if(!isWasmInitialized) {
33006 throw new Error("initializeWasm() must be awaited first!");
33008 const nativeResponseValue = wasm.TS_Pong_clone(orig);
33009 return nativeResponseValue;
33011 // uint64_t Pong_hash(const struct LDKPong *NONNULL_PTR o);
33013 export function Pong_hash(o: bigint): bigint {
33014 if(!isWasmInitialized) {
33015 throw new Error("initializeWasm() must be awaited first!");
33017 const nativeResponseValue = wasm.TS_Pong_hash(o);
33018 return nativeResponseValue;
33020 // bool Pong_eq(const struct LDKPong *NONNULL_PTR a, const struct LDKPong *NONNULL_PTR b);
33022 export function Pong_eq(a: bigint, b: bigint): boolean {
33023 if(!isWasmInitialized) {
33024 throw new Error("initializeWasm() must be awaited first!");
33026 const nativeResponseValue = wasm.TS_Pong_eq(a, b);
33027 return nativeResponseValue;
33029 // void OpenChannel_free(struct LDKOpenChannel this_obj);
33031 export function OpenChannel_free(this_obj: bigint): void {
33032 if(!isWasmInitialized) {
33033 throw new Error("initializeWasm() must be awaited first!");
33035 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
33036 // debug statements here
33038 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
33040 export function OpenChannel_get_chain_hash(this_ptr: bigint): number {
33041 if(!isWasmInitialized) {
33042 throw new Error("initializeWasm() must be awaited first!");
33044 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
33045 return nativeResponseValue;
33047 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33049 export function OpenChannel_set_chain_hash(this_ptr: bigint, val: number): void {
33050 if(!isWasmInitialized) {
33051 throw new Error("initializeWasm() must be awaited first!");
33053 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
33054 // debug statements here
33056 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
33058 export function OpenChannel_get_temporary_channel_id(this_ptr: bigint): number {
33059 if(!isWasmInitialized) {
33060 throw new Error("initializeWasm() must be awaited first!");
33062 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
33063 return nativeResponseValue;
33065 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33067 export function OpenChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
33068 if(!isWasmInitialized) {
33069 throw new Error("initializeWasm() must be awaited first!");
33071 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
33072 // debug statements here
33074 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33076 export function OpenChannel_get_funding_satoshis(this_ptr: bigint): bigint {
33077 if(!isWasmInitialized) {
33078 throw new Error("initializeWasm() must be awaited first!");
33080 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
33081 return nativeResponseValue;
33083 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
33085 export function OpenChannel_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
33086 if(!isWasmInitialized) {
33087 throw new Error("initializeWasm() must be awaited first!");
33089 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
33090 // debug statements here
33092 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33094 export function OpenChannel_get_push_msat(this_ptr: bigint): bigint {
33095 if(!isWasmInitialized) {
33096 throw new Error("initializeWasm() must be awaited first!");
33098 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
33099 return nativeResponseValue;
33101 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
33103 export function OpenChannel_set_push_msat(this_ptr: bigint, val: bigint): void {
33104 if(!isWasmInitialized) {
33105 throw new Error("initializeWasm() must be awaited first!");
33107 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
33108 // debug statements here
33110 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33112 export function OpenChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
33113 if(!isWasmInitialized) {
33114 throw new Error("initializeWasm() must be awaited first!");
33116 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
33117 return nativeResponseValue;
33119 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
33121 export function OpenChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
33122 if(!isWasmInitialized) {
33123 throw new Error("initializeWasm() must be awaited first!");
33125 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
33126 // debug statements here
33128 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33130 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
33131 if(!isWasmInitialized) {
33132 throw new Error("initializeWasm() must be awaited first!");
33134 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
33135 return nativeResponseValue;
33137 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
33139 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
33140 if(!isWasmInitialized) {
33141 throw new Error("initializeWasm() must be awaited first!");
33143 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
33144 // debug statements here
33146 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33148 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
33149 if(!isWasmInitialized) {
33150 throw new Error("initializeWasm() must be awaited first!");
33152 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
33153 return nativeResponseValue;
33155 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
33157 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
33158 if(!isWasmInitialized) {
33159 throw new Error("initializeWasm() must be awaited first!");
33161 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
33162 // debug statements here
33164 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33166 export function OpenChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
33167 if(!isWasmInitialized) {
33168 throw new Error("initializeWasm() must be awaited first!");
33170 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
33171 return nativeResponseValue;
33173 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
33175 export function OpenChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
33176 if(!isWasmInitialized) {
33177 throw new Error("initializeWasm() must be awaited first!");
33179 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
33180 // debug statements here
33182 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33184 export function OpenChannel_get_feerate_per_kw(this_ptr: bigint): number {
33185 if(!isWasmInitialized) {
33186 throw new Error("initializeWasm() must be awaited first!");
33188 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
33189 return nativeResponseValue;
33191 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
33193 export function OpenChannel_set_feerate_per_kw(this_ptr: bigint, val: number): void {
33194 if(!isWasmInitialized) {
33195 throw new Error("initializeWasm() must be awaited first!");
33197 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
33198 // debug statements here
33200 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33202 export function OpenChannel_get_to_self_delay(this_ptr: bigint): number {
33203 if(!isWasmInitialized) {
33204 throw new Error("initializeWasm() must be awaited first!");
33206 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
33207 return nativeResponseValue;
33209 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
33211 export function OpenChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
33212 if(!isWasmInitialized) {
33213 throw new Error("initializeWasm() must be awaited first!");
33215 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
33216 // debug statements here
33218 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33220 export function OpenChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
33221 if(!isWasmInitialized) {
33222 throw new Error("initializeWasm() must be awaited first!");
33224 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
33225 return nativeResponseValue;
33227 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
33229 export function OpenChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
33230 if(!isWasmInitialized) {
33231 throw new Error("initializeWasm() must be awaited first!");
33233 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
33234 // debug statements here
33236 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33238 export function OpenChannel_get_funding_pubkey(this_ptr: bigint): number {
33239 if(!isWasmInitialized) {
33240 throw new Error("initializeWasm() must be awaited first!");
33242 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
33243 return nativeResponseValue;
33245 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33247 export function OpenChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
33248 if(!isWasmInitialized) {
33249 throw new Error("initializeWasm() must be awaited first!");
33251 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
33252 // debug statements here
33254 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33256 export function OpenChannel_get_revocation_basepoint(this_ptr: bigint): number {
33257 if(!isWasmInitialized) {
33258 throw new Error("initializeWasm() must be awaited first!");
33260 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
33261 return nativeResponseValue;
33263 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33265 export function OpenChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
33266 if(!isWasmInitialized) {
33267 throw new Error("initializeWasm() must be awaited first!");
33269 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
33270 // debug statements here
33272 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33274 export function OpenChannel_get_payment_point(this_ptr: bigint): number {
33275 if(!isWasmInitialized) {
33276 throw new Error("initializeWasm() must be awaited first!");
33278 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
33279 return nativeResponseValue;
33281 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33283 export function OpenChannel_set_payment_point(this_ptr: bigint, val: number): void {
33284 if(!isWasmInitialized) {
33285 throw new Error("initializeWasm() must be awaited first!");
33287 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
33288 // debug statements here
33290 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33292 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
33293 if(!isWasmInitialized) {
33294 throw new Error("initializeWasm() must be awaited first!");
33296 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
33297 return nativeResponseValue;
33299 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33301 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
33302 if(!isWasmInitialized) {
33303 throw new Error("initializeWasm() must be awaited first!");
33305 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
33306 // debug statements here
33308 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33310 export function OpenChannel_get_htlc_basepoint(this_ptr: bigint): number {
33311 if(!isWasmInitialized) {
33312 throw new Error("initializeWasm() must be awaited first!");
33314 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
33315 return nativeResponseValue;
33317 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33319 export function OpenChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
33320 if(!isWasmInitialized) {
33321 throw new Error("initializeWasm() must be awaited first!");
33323 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
33324 // debug statements here
33326 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33328 export function OpenChannel_get_first_per_commitment_point(this_ptr: bigint): number {
33329 if(!isWasmInitialized) {
33330 throw new Error("initializeWasm() must be awaited first!");
33332 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
33333 return nativeResponseValue;
33335 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33337 export function OpenChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
33338 if(!isWasmInitialized) {
33339 throw new Error("initializeWasm() must be awaited first!");
33341 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
33342 // debug statements here
33344 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33346 export function OpenChannel_get_channel_flags(this_ptr: bigint): number {
33347 if(!isWasmInitialized) {
33348 throw new Error("initializeWasm() must be awaited first!");
33350 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
33351 return nativeResponseValue;
33353 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
33355 export function OpenChannel_set_channel_flags(this_ptr: bigint, val: number): void {
33356 if(!isWasmInitialized) {
33357 throw new Error("initializeWasm() must be awaited first!");
33359 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
33360 // debug statements here
33362 // struct LDKCOption_CVec_u8ZZ OpenChannel_get_shutdown_scriptpubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33364 export function OpenChannel_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
33365 if(!isWasmInitialized) {
33366 throw new Error("initializeWasm() must be awaited first!");
33368 const nativeResponseValue = wasm.TS_OpenChannel_get_shutdown_scriptpubkey(this_ptr);
33369 return nativeResponseValue;
33371 // void OpenChannel_set_shutdown_scriptpubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
33373 export function OpenChannel_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
33374 if(!isWasmInitialized) {
33375 throw new Error("initializeWasm() must be awaited first!");
33377 const nativeResponseValue = wasm.TS_OpenChannel_set_shutdown_scriptpubkey(this_ptr, val);
33378 // debug statements here
33380 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
33382 export function OpenChannel_get_channel_type(this_ptr: bigint): bigint {
33383 if(!isWasmInitialized) {
33384 throw new Error("initializeWasm() must be awaited first!");
33386 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
33387 return nativeResponseValue;
33389 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
33391 export function OpenChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
33392 if(!isWasmInitialized) {
33393 throw new Error("initializeWasm() must be awaited first!");
33395 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
33396 // debug statements here
33398 // 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);
33400 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 {
33401 if(!isWasmInitialized) {
33402 throw new Error("initializeWasm() must be awaited first!");
33404 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);
33405 return nativeResponseValue;
33407 // uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
33409 export function OpenChannel_clone_ptr(arg: bigint): bigint {
33410 if(!isWasmInitialized) {
33411 throw new Error("initializeWasm() must be awaited first!");
33413 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
33414 return nativeResponseValue;
33416 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
33418 export function OpenChannel_clone(orig: bigint): bigint {
33419 if(!isWasmInitialized) {
33420 throw new Error("initializeWasm() must be awaited first!");
33422 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
33423 return nativeResponseValue;
33425 // uint64_t OpenChannel_hash(const struct LDKOpenChannel *NONNULL_PTR o);
33427 export function OpenChannel_hash(o: bigint): bigint {
33428 if(!isWasmInitialized) {
33429 throw new Error("initializeWasm() must be awaited first!");
33431 const nativeResponseValue = wasm.TS_OpenChannel_hash(o);
33432 return nativeResponseValue;
33434 // bool OpenChannel_eq(const struct LDKOpenChannel *NONNULL_PTR a, const struct LDKOpenChannel *NONNULL_PTR b);
33436 export function OpenChannel_eq(a: bigint, b: bigint): boolean {
33437 if(!isWasmInitialized) {
33438 throw new Error("initializeWasm() must be awaited first!");
33440 const nativeResponseValue = wasm.TS_OpenChannel_eq(a, b);
33441 return nativeResponseValue;
33443 // void OpenChannelV2_free(struct LDKOpenChannelV2 this_obj);
33445 export function OpenChannelV2_free(this_obj: bigint): void {
33446 if(!isWasmInitialized) {
33447 throw new Error("initializeWasm() must be awaited first!");
33449 const nativeResponseValue = wasm.TS_OpenChannelV2_free(this_obj);
33450 // debug statements here
33452 // const uint8_t (*OpenChannelV2_get_chain_hash(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr))[32];
33454 export function OpenChannelV2_get_chain_hash(this_ptr: bigint): number {
33455 if(!isWasmInitialized) {
33456 throw new Error("initializeWasm() must be awaited first!");
33458 const nativeResponseValue = wasm.TS_OpenChannelV2_get_chain_hash(this_ptr);
33459 return nativeResponseValue;
33461 // void OpenChannelV2_set_chain_hash(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33463 export function OpenChannelV2_set_chain_hash(this_ptr: bigint, val: number): void {
33464 if(!isWasmInitialized) {
33465 throw new Error("initializeWasm() must be awaited first!");
33467 const nativeResponseValue = wasm.TS_OpenChannelV2_set_chain_hash(this_ptr, val);
33468 // debug statements here
33470 // const uint8_t (*OpenChannelV2_get_temporary_channel_id(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr))[32];
33472 export function OpenChannelV2_get_temporary_channel_id(this_ptr: bigint): number {
33473 if(!isWasmInitialized) {
33474 throw new Error("initializeWasm() must be awaited first!");
33476 const nativeResponseValue = wasm.TS_OpenChannelV2_get_temporary_channel_id(this_ptr);
33477 return nativeResponseValue;
33479 // void OpenChannelV2_set_temporary_channel_id(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33481 export function OpenChannelV2_set_temporary_channel_id(this_ptr: bigint, val: number): void {
33482 if(!isWasmInitialized) {
33483 throw new Error("initializeWasm() must be awaited first!");
33485 const nativeResponseValue = wasm.TS_OpenChannelV2_set_temporary_channel_id(this_ptr, val);
33486 // debug statements here
33488 // uint32_t OpenChannelV2_get_funding_feerate_sat_per_1000_weight(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33490 export function OpenChannelV2_get_funding_feerate_sat_per_1000_weight(this_ptr: bigint): number {
33491 if(!isWasmInitialized) {
33492 throw new Error("initializeWasm() must be awaited first!");
33494 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_feerate_sat_per_1000_weight(this_ptr);
33495 return nativeResponseValue;
33497 // void OpenChannelV2_set_funding_feerate_sat_per_1000_weight(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
33499 export function OpenChannelV2_set_funding_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
33500 if(!isWasmInitialized) {
33501 throw new Error("initializeWasm() must be awaited first!");
33503 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_feerate_sat_per_1000_weight(this_ptr, val);
33504 // debug statements here
33506 // uint32_t OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33508 export function OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(this_ptr: bigint): number {
33509 if(!isWasmInitialized) {
33510 throw new Error("initializeWasm() must be awaited first!");
33512 const nativeResponseValue = wasm.TS_OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(this_ptr);
33513 return nativeResponseValue;
33515 // void OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
33517 export function OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
33518 if(!isWasmInitialized) {
33519 throw new Error("initializeWasm() must be awaited first!");
33521 const nativeResponseValue = wasm.TS_OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(this_ptr, val);
33522 // debug statements here
33524 // uint64_t OpenChannelV2_get_funding_satoshis(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33526 export function OpenChannelV2_get_funding_satoshis(this_ptr: bigint): bigint {
33527 if(!isWasmInitialized) {
33528 throw new Error("initializeWasm() must be awaited first!");
33530 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_satoshis(this_ptr);
33531 return nativeResponseValue;
33533 // void OpenChannelV2_set_funding_satoshis(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
33535 export function OpenChannelV2_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
33536 if(!isWasmInitialized) {
33537 throw new Error("initializeWasm() must be awaited first!");
33539 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_satoshis(this_ptr, val);
33540 // debug statements here
33542 // uint64_t OpenChannelV2_get_dust_limit_satoshis(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33544 export function OpenChannelV2_get_dust_limit_satoshis(this_ptr: bigint): bigint {
33545 if(!isWasmInitialized) {
33546 throw new Error("initializeWasm() must be awaited first!");
33548 const nativeResponseValue = wasm.TS_OpenChannelV2_get_dust_limit_satoshis(this_ptr);
33549 return nativeResponseValue;
33551 // void OpenChannelV2_set_dust_limit_satoshis(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
33553 export function OpenChannelV2_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
33554 if(!isWasmInitialized) {
33555 throw new Error("initializeWasm() must be awaited first!");
33557 const nativeResponseValue = wasm.TS_OpenChannelV2_set_dust_limit_satoshis(this_ptr, val);
33558 // debug statements here
33560 // uint64_t OpenChannelV2_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33562 export function OpenChannelV2_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
33563 if(!isWasmInitialized) {
33564 throw new Error("initializeWasm() must be awaited first!");
33566 const nativeResponseValue = wasm.TS_OpenChannelV2_get_max_htlc_value_in_flight_msat(this_ptr);
33567 return nativeResponseValue;
33569 // void OpenChannelV2_set_max_htlc_value_in_flight_msat(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
33571 export function OpenChannelV2_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
33572 if(!isWasmInitialized) {
33573 throw new Error("initializeWasm() must be awaited first!");
33575 const nativeResponseValue = wasm.TS_OpenChannelV2_set_max_htlc_value_in_flight_msat(this_ptr, val);
33576 // debug statements here
33578 // uint64_t OpenChannelV2_get_htlc_minimum_msat(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33580 export function OpenChannelV2_get_htlc_minimum_msat(this_ptr: bigint): bigint {
33581 if(!isWasmInitialized) {
33582 throw new Error("initializeWasm() must be awaited first!");
33584 const nativeResponseValue = wasm.TS_OpenChannelV2_get_htlc_minimum_msat(this_ptr);
33585 return nativeResponseValue;
33587 // void OpenChannelV2_set_htlc_minimum_msat(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
33589 export function OpenChannelV2_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
33590 if(!isWasmInitialized) {
33591 throw new Error("initializeWasm() must be awaited first!");
33593 const nativeResponseValue = wasm.TS_OpenChannelV2_set_htlc_minimum_msat(this_ptr, val);
33594 // debug statements here
33596 // uint16_t OpenChannelV2_get_to_self_delay(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33598 export function OpenChannelV2_get_to_self_delay(this_ptr: bigint): number {
33599 if(!isWasmInitialized) {
33600 throw new Error("initializeWasm() must be awaited first!");
33602 const nativeResponseValue = wasm.TS_OpenChannelV2_get_to_self_delay(this_ptr);
33603 return nativeResponseValue;
33605 // void OpenChannelV2_set_to_self_delay(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
33607 export function OpenChannelV2_set_to_self_delay(this_ptr: bigint, val: number): void {
33608 if(!isWasmInitialized) {
33609 throw new Error("initializeWasm() must be awaited first!");
33611 const nativeResponseValue = wasm.TS_OpenChannelV2_set_to_self_delay(this_ptr, val);
33612 // debug statements here
33614 // uint16_t OpenChannelV2_get_max_accepted_htlcs(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33616 export function OpenChannelV2_get_max_accepted_htlcs(this_ptr: bigint): number {
33617 if(!isWasmInitialized) {
33618 throw new Error("initializeWasm() must be awaited first!");
33620 const nativeResponseValue = wasm.TS_OpenChannelV2_get_max_accepted_htlcs(this_ptr);
33621 return nativeResponseValue;
33623 // void OpenChannelV2_set_max_accepted_htlcs(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
33625 export function OpenChannelV2_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
33626 if(!isWasmInitialized) {
33627 throw new Error("initializeWasm() must be awaited first!");
33629 const nativeResponseValue = wasm.TS_OpenChannelV2_set_max_accepted_htlcs(this_ptr, val);
33630 // debug statements here
33632 // uint32_t OpenChannelV2_get_locktime(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33634 export function OpenChannelV2_get_locktime(this_ptr: bigint): number {
33635 if(!isWasmInitialized) {
33636 throw new Error("initializeWasm() must be awaited first!");
33638 const nativeResponseValue = wasm.TS_OpenChannelV2_get_locktime(this_ptr);
33639 return nativeResponseValue;
33641 // void OpenChannelV2_set_locktime(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
33643 export function OpenChannelV2_set_locktime(this_ptr: bigint, val: number): void {
33644 if(!isWasmInitialized) {
33645 throw new Error("initializeWasm() must be awaited first!");
33647 const nativeResponseValue = wasm.TS_OpenChannelV2_set_locktime(this_ptr, val);
33648 // debug statements here
33650 // struct LDKPublicKey OpenChannelV2_get_funding_pubkey(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33652 export function OpenChannelV2_get_funding_pubkey(this_ptr: bigint): number {
33653 if(!isWasmInitialized) {
33654 throw new Error("initializeWasm() must be awaited first!");
33656 const nativeResponseValue = wasm.TS_OpenChannelV2_get_funding_pubkey(this_ptr);
33657 return nativeResponseValue;
33659 // void OpenChannelV2_set_funding_pubkey(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33661 export function OpenChannelV2_set_funding_pubkey(this_ptr: bigint, val: number): void {
33662 if(!isWasmInitialized) {
33663 throw new Error("initializeWasm() must be awaited first!");
33665 const nativeResponseValue = wasm.TS_OpenChannelV2_set_funding_pubkey(this_ptr, val);
33666 // debug statements here
33668 // struct LDKPublicKey OpenChannelV2_get_revocation_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33670 export function OpenChannelV2_get_revocation_basepoint(this_ptr: bigint): number {
33671 if(!isWasmInitialized) {
33672 throw new Error("initializeWasm() must be awaited first!");
33674 const nativeResponseValue = wasm.TS_OpenChannelV2_get_revocation_basepoint(this_ptr);
33675 return nativeResponseValue;
33677 // void OpenChannelV2_set_revocation_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33679 export function OpenChannelV2_set_revocation_basepoint(this_ptr: bigint, val: number): void {
33680 if(!isWasmInitialized) {
33681 throw new Error("initializeWasm() must be awaited first!");
33683 const nativeResponseValue = wasm.TS_OpenChannelV2_set_revocation_basepoint(this_ptr, val);
33684 // debug statements here
33686 // struct LDKPublicKey OpenChannelV2_get_payment_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33688 export function OpenChannelV2_get_payment_basepoint(this_ptr: bigint): number {
33689 if(!isWasmInitialized) {
33690 throw new Error("initializeWasm() must be awaited first!");
33692 const nativeResponseValue = wasm.TS_OpenChannelV2_get_payment_basepoint(this_ptr);
33693 return nativeResponseValue;
33695 // void OpenChannelV2_set_payment_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33697 export function OpenChannelV2_set_payment_basepoint(this_ptr: bigint, val: number): void {
33698 if(!isWasmInitialized) {
33699 throw new Error("initializeWasm() must be awaited first!");
33701 const nativeResponseValue = wasm.TS_OpenChannelV2_set_payment_basepoint(this_ptr, val);
33702 // debug statements here
33704 // struct LDKPublicKey OpenChannelV2_get_delayed_payment_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33706 export function OpenChannelV2_get_delayed_payment_basepoint(this_ptr: bigint): number {
33707 if(!isWasmInitialized) {
33708 throw new Error("initializeWasm() must be awaited first!");
33710 const nativeResponseValue = wasm.TS_OpenChannelV2_get_delayed_payment_basepoint(this_ptr);
33711 return nativeResponseValue;
33713 // void OpenChannelV2_set_delayed_payment_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33715 export function OpenChannelV2_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
33716 if(!isWasmInitialized) {
33717 throw new Error("initializeWasm() must be awaited first!");
33719 const nativeResponseValue = wasm.TS_OpenChannelV2_set_delayed_payment_basepoint(this_ptr, val);
33720 // debug statements here
33722 // struct LDKPublicKey OpenChannelV2_get_htlc_basepoint(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33724 export function OpenChannelV2_get_htlc_basepoint(this_ptr: bigint): number {
33725 if(!isWasmInitialized) {
33726 throw new Error("initializeWasm() must be awaited first!");
33728 const nativeResponseValue = wasm.TS_OpenChannelV2_get_htlc_basepoint(this_ptr);
33729 return nativeResponseValue;
33731 // void OpenChannelV2_set_htlc_basepoint(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33733 export function OpenChannelV2_set_htlc_basepoint(this_ptr: bigint, val: number): void {
33734 if(!isWasmInitialized) {
33735 throw new Error("initializeWasm() must be awaited first!");
33737 const nativeResponseValue = wasm.TS_OpenChannelV2_set_htlc_basepoint(this_ptr, val);
33738 // debug statements here
33740 // struct LDKPublicKey OpenChannelV2_get_first_per_commitment_point(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33742 export function OpenChannelV2_get_first_per_commitment_point(this_ptr: bigint): number {
33743 if(!isWasmInitialized) {
33744 throw new Error("initializeWasm() must be awaited first!");
33746 const nativeResponseValue = wasm.TS_OpenChannelV2_get_first_per_commitment_point(this_ptr);
33747 return nativeResponseValue;
33749 // void OpenChannelV2_set_first_per_commitment_point(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33751 export function OpenChannelV2_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
33752 if(!isWasmInitialized) {
33753 throw new Error("initializeWasm() must be awaited first!");
33755 const nativeResponseValue = wasm.TS_OpenChannelV2_set_first_per_commitment_point(this_ptr, val);
33756 // debug statements here
33758 // struct LDKPublicKey OpenChannelV2_get_second_per_commitment_point(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33760 export function OpenChannelV2_get_second_per_commitment_point(this_ptr: bigint): number {
33761 if(!isWasmInitialized) {
33762 throw new Error("initializeWasm() must be awaited first!");
33764 const nativeResponseValue = wasm.TS_OpenChannelV2_get_second_per_commitment_point(this_ptr);
33765 return nativeResponseValue;
33767 // void OpenChannelV2_set_second_per_commitment_point(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
33769 export function OpenChannelV2_set_second_per_commitment_point(this_ptr: bigint, val: number): void {
33770 if(!isWasmInitialized) {
33771 throw new Error("initializeWasm() must be awaited first!");
33773 const nativeResponseValue = wasm.TS_OpenChannelV2_set_second_per_commitment_point(this_ptr, val);
33774 // debug statements here
33776 // uint8_t OpenChannelV2_get_channel_flags(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33778 export function OpenChannelV2_get_channel_flags(this_ptr: bigint): number {
33779 if(!isWasmInitialized) {
33780 throw new Error("initializeWasm() must be awaited first!");
33782 const nativeResponseValue = wasm.TS_OpenChannelV2_get_channel_flags(this_ptr);
33783 return nativeResponseValue;
33785 // void OpenChannelV2_set_channel_flags(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, uint8_t val);
33787 export function OpenChannelV2_set_channel_flags(this_ptr: bigint, val: number): void {
33788 if(!isWasmInitialized) {
33789 throw new Error("initializeWasm() must be awaited first!");
33791 const nativeResponseValue = wasm.TS_OpenChannelV2_set_channel_flags(this_ptr, val);
33792 // debug statements here
33794 // struct LDKCOption_CVec_u8ZZ OpenChannelV2_get_shutdown_scriptpubkey(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33796 export function OpenChannelV2_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
33797 if(!isWasmInitialized) {
33798 throw new Error("initializeWasm() must be awaited first!");
33800 const nativeResponseValue = wasm.TS_OpenChannelV2_get_shutdown_scriptpubkey(this_ptr);
33801 return nativeResponseValue;
33803 // void OpenChannelV2_set_shutdown_scriptpubkey(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
33805 export function OpenChannelV2_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
33806 if(!isWasmInitialized) {
33807 throw new Error("initializeWasm() must be awaited first!");
33809 const nativeResponseValue = wasm.TS_OpenChannelV2_set_shutdown_scriptpubkey(this_ptr, val);
33810 // debug statements here
33812 // struct LDKChannelTypeFeatures OpenChannelV2_get_channel_type(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33814 export function OpenChannelV2_get_channel_type(this_ptr: bigint): bigint {
33815 if(!isWasmInitialized) {
33816 throw new Error("initializeWasm() must be awaited first!");
33818 const nativeResponseValue = wasm.TS_OpenChannelV2_get_channel_type(this_ptr);
33819 return nativeResponseValue;
33821 // void OpenChannelV2_set_channel_type(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
33823 export function OpenChannelV2_set_channel_type(this_ptr: bigint, val: bigint): void {
33824 if(!isWasmInitialized) {
33825 throw new Error("initializeWasm() must be awaited first!");
33827 const nativeResponseValue = wasm.TS_OpenChannelV2_set_channel_type(this_ptr, val);
33828 // debug statements here
33830 // enum LDKCOption_NoneZ OpenChannelV2_get_require_confirmed_inputs(const struct LDKOpenChannelV2 *NONNULL_PTR this_ptr);
33832 export function OpenChannelV2_get_require_confirmed_inputs(this_ptr: bigint): COption_NoneZ {
33833 if(!isWasmInitialized) {
33834 throw new Error("initializeWasm() must be awaited first!");
33836 const nativeResponseValue = wasm.TS_OpenChannelV2_get_require_confirmed_inputs(this_ptr);
33837 return nativeResponseValue;
33839 // void OpenChannelV2_set_require_confirmed_inputs(struct LDKOpenChannelV2 *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
33841 export function OpenChannelV2_set_require_confirmed_inputs(this_ptr: bigint, val: COption_NoneZ): void {
33842 if(!isWasmInitialized) {
33843 throw new Error("initializeWasm() must be awaited first!");
33845 const nativeResponseValue = wasm.TS_OpenChannelV2_set_require_confirmed_inputs(this_ptr, val);
33846 // debug statements here
33848 // 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);
33850 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 {
33851 if(!isWasmInitialized) {
33852 throw new Error("initializeWasm() must be awaited first!");
33854 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);
33855 return nativeResponseValue;
33857 // uint64_t OpenChannelV2_clone_ptr(LDKOpenChannelV2 *NONNULL_PTR arg);
33859 export function OpenChannelV2_clone_ptr(arg: bigint): bigint {
33860 if(!isWasmInitialized) {
33861 throw new Error("initializeWasm() must be awaited first!");
33863 const nativeResponseValue = wasm.TS_OpenChannelV2_clone_ptr(arg);
33864 return nativeResponseValue;
33866 // struct LDKOpenChannelV2 OpenChannelV2_clone(const struct LDKOpenChannelV2 *NONNULL_PTR orig);
33868 export function OpenChannelV2_clone(orig: bigint): bigint {
33869 if(!isWasmInitialized) {
33870 throw new Error("initializeWasm() must be awaited first!");
33872 const nativeResponseValue = wasm.TS_OpenChannelV2_clone(orig);
33873 return nativeResponseValue;
33875 // uint64_t OpenChannelV2_hash(const struct LDKOpenChannelV2 *NONNULL_PTR o);
33877 export function OpenChannelV2_hash(o: bigint): bigint {
33878 if(!isWasmInitialized) {
33879 throw new Error("initializeWasm() must be awaited first!");
33881 const nativeResponseValue = wasm.TS_OpenChannelV2_hash(o);
33882 return nativeResponseValue;
33884 // bool OpenChannelV2_eq(const struct LDKOpenChannelV2 *NONNULL_PTR a, const struct LDKOpenChannelV2 *NONNULL_PTR b);
33886 export function OpenChannelV2_eq(a: bigint, b: bigint): boolean {
33887 if(!isWasmInitialized) {
33888 throw new Error("initializeWasm() must be awaited first!");
33890 const nativeResponseValue = wasm.TS_OpenChannelV2_eq(a, b);
33891 return nativeResponseValue;
33893 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
33895 export function AcceptChannel_free(this_obj: bigint): void {
33896 if(!isWasmInitialized) {
33897 throw new Error("initializeWasm() must be awaited first!");
33899 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
33900 // debug statements here
33902 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
33904 export function AcceptChannel_get_temporary_channel_id(this_ptr: bigint): number {
33905 if(!isWasmInitialized) {
33906 throw new Error("initializeWasm() must be awaited first!");
33908 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
33909 return nativeResponseValue;
33911 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
33913 export function AcceptChannel_set_temporary_channel_id(this_ptr: bigint, val: number): void {
33914 if(!isWasmInitialized) {
33915 throw new Error("initializeWasm() must be awaited first!");
33917 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
33918 // debug statements here
33920 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
33922 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: bigint): bigint {
33923 if(!isWasmInitialized) {
33924 throw new Error("initializeWasm() must be awaited first!");
33926 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
33927 return nativeResponseValue;
33929 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
33931 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
33932 if(!isWasmInitialized) {
33933 throw new Error("initializeWasm() must be awaited first!");
33935 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
33936 // debug statements here
33938 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
33940 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
33941 if(!isWasmInitialized) {
33942 throw new Error("initializeWasm() must be awaited first!");
33944 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
33945 return nativeResponseValue;
33947 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
33949 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
33950 if(!isWasmInitialized) {
33951 throw new Error("initializeWasm() must be awaited first!");
33953 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
33954 // debug statements here
33956 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
33958 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: bigint): bigint {
33959 if(!isWasmInitialized) {
33960 throw new Error("initializeWasm() must be awaited first!");
33962 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
33963 return nativeResponseValue;
33965 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
33967 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: bigint, val: bigint): void {
33968 if(!isWasmInitialized) {
33969 throw new Error("initializeWasm() must be awaited first!");
33971 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
33972 // debug statements here
33974 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
33976 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: bigint): bigint {
33977 if(!isWasmInitialized) {
33978 throw new Error("initializeWasm() must be awaited first!");
33980 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
33981 return nativeResponseValue;
33983 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
33985 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
33986 if(!isWasmInitialized) {
33987 throw new Error("initializeWasm() must be awaited first!");
33989 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
33990 // debug statements here
33992 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
33994 export function AcceptChannel_get_minimum_depth(this_ptr: bigint): number {
33995 if(!isWasmInitialized) {
33996 throw new Error("initializeWasm() must be awaited first!");
33998 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
33999 return nativeResponseValue;
34001 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
34003 export function AcceptChannel_set_minimum_depth(this_ptr: bigint, val: number): void {
34004 if(!isWasmInitialized) {
34005 throw new Error("initializeWasm() must be awaited first!");
34007 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
34008 // debug statements here
34010 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
34012 export function AcceptChannel_get_to_self_delay(this_ptr: bigint): number {
34013 if(!isWasmInitialized) {
34014 throw new Error("initializeWasm() must be awaited first!");
34016 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
34017 return nativeResponseValue;
34019 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
34021 export function AcceptChannel_set_to_self_delay(this_ptr: bigint, val: number): void {
34022 if(!isWasmInitialized) {
34023 throw new Error("initializeWasm() must be awaited first!");
34025 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
34026 // debug statements here
34028 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
34030 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: bigint): number {
34031 if(!isWasmInitialized) {
34032 throw new Error("initializeWasm() must be awaited first!");
34034 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
34035 return nativeResponseValue;
34037 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
34039 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
34040 if(!isWasmInitialized) {
34041 throw new Error("initializeWasm() must be awaited first!");
34043 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
34044 // debug statements here
34046 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
34048 export function AcceptChannel_get_funding_pubkey(this_ptr: bigint): number {
34049 if(!isWasmInitialized) {
34050 throw new Error("initializeWasm() must be awaited first!");
34052 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
34053 return nativeResponseValue;
34055 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34057 export function AcceptChannel_set_funding_pubkey(this_ptr: bigint, val: number): void {
34058 if(!isWasmInitialized) {
34059 throw new Error("initializeWasm() must be awaited first!");
34061 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
34062 // debug statements here
34064 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
34066 export function AcceptChannel_get_revocation_basepoint(this_ptr: bigint): number {
34067 if(!isWasmInitialized) {
34068 throw new Error("initializeWasm() must be awaited first!");
34070 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
34071 return nativeResponseValue;
34073 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34075 export function AcceptChannel_set_revocation_basepoint(this_ptr: bigint, val: number): void {
34076 if(!isWasmInitialized) {
34077 throw new Error("initializeWasm() must be awaited first!");
34079 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
34080 // debug statements here
34082 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
34084 export function AcceptChannel_get_payment_point(this_ptr: bigint): number {
34085 if(!isWasmInitialized) {
34086 throw new Error("initializeWasm() must be awaited first!");
34088 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
34089 return nativeResponseValue;
34091 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34093 export function AcceptChannel_set_payment_point(this_ptr: bigint, val: number): void {
34094 if(!isWasmInitialized) {
34095 throw new Error("initializeWasm() must be awaited first!");
34097 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
34098 // debug statements here
34100 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
34102 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: bigint): number {
34103 if(!isWasmInitialized) {
34104 throw new Error("initializeWasm() must be awaited first!");
34106 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
34107 return nativeResponseValue;
34109 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34111 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
34112 if(!isWasmInitialized) {
34113 throw new Error("initializeWasm() must be awaited first!");
34115 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
34116 // debug statements here
34118 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
34120 export function AcceptChannel_get_htlc_basepoint(this_ptr: bigint): number {
34121 if(!isWasmInitialized) {
34122 throw new Error("initializeWasm() must be awaited first!");
34124 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
34125 return nativeResponseValue;
34127 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34129 export function AcceptChannel_set_htlc_basepoint(this_ptr: bigint, val: number): void {
34130 if(!isWasmInitialized) {
34131 throw new Error("initializeWasm() must be awaited first!");
34133 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
34134 // debug statements here
34136 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
34138 export function AcceptChannel_get_first_per_commitment_point(this_ptr: bigint): number {
34139 if(!isWasmInitialized) {
34140 throw new Error("initializeWasm() must be awaited first!");
34142 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
34143 return nativeResponseValue;
34145 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34147 export function AcceptChannel_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
34148 if(!isWasmInitialized) {
34149 throw new Error("initializeWasm() must be awaited first!");
34151 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
34152 // debug statements here
34154 // struct LDKCOption_CVec_u8ZZ AcceptChannel_get_shutdown_scriptpubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
34156 export function AcceptChannel_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
34157 if(!isWasmInitialized) {
34158 throw new Error("initializeWasm() must be awaited first!");
34160 const nativeResponseValue = wasm.TS_AcceptChannel_get_shutdown_scriptpubkey(this_ptr);
34161 return nativeResponseValue;
34163 // void AcceptChannel_set_shutdown_scriptpubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
34165 export function AcceptChannel_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
34166 if(!isWasmInitialized) {
34167 throw new Error("initializeWasm() must be awaited first!");
34169 const nativeResponseValue = wasm.TS_AcceptChannel_set_shutdown_scriptpubkey(this_ptr, val);
34170 // debug statements here
34172 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
34174 export function AcceptChannel_get_channel_type(this_ptr: bigint): bigint {
34175 if(!isWasmInitialized) {
34176 throw new Error("initializeWasm() must be awaited first!");
34178 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
34179 return nativeResponseValue;
34181 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
34183 export function AcceptChannel_set_channel_type(this_ptr: bigint, val: bigint): void {
34184 if(!isWasmInitialized) {
34185 throw new Error("initializeWasm() must be awaited first!");
34187 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
34188 // debug statements here
34190 // 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);
34192 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 {
34193 if(!isWasmInitialized) {
34194 throw new Error("initializeWasm() must be awaited first!");
34196 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);
34197 return nativeResponseValue;
34199 // uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
34201 export function AcceptChannel_clone_ptr(arg: bigint): bigint {
34202 if(!isWasmInitialized) {
34203 throw new Error("initializeWasm() must be awaited first!");
34205 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
34206 return nativeResponseValue;
34208 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
34210 export function AcceptChannel_clone(orig: bigint): bigint {
34211 if(!isWasmInitialized) {
34212 throw new Error("initializeWasm() must be awaited first!");
34214 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
34215 return nativeResponseValue;
34217 // uint64_t AcceptChannel_hash(const struct LDKAcceptChannel *NONNULL_PTR o);
34219 export function AcceptChannel_hash(o: bigint): bigint {
34220 if(!isWasmInitialized) {
34221 throw new Error("initializeWasm() must be awaited first!");
34223 const nativeResponseValue = wasm.TS_AcceptChannel_hash(o);
34224 return nativeResponseValue;
34226 // bool AcceptChannel_eq(const struct LDKAcceptChannel *NONNULL_PTR a, const struct LDKAcceptChannel *NONNULL_PTR b);
34228 export function AcceptChannel_eq(a: bigint, b: bigint): boolean {
34229 if(!isWasmInitialized) {
34230 throw new Error("initializeWasm() must be awaited first!");
34232 const nativeResponseValue = wasm.TS_AcceptChannel_eq(a, b);
34233 return nativeResponseValue;
34235 // void AcceptChannelV2_free(struct LDKAcceptChannelV2 this_obj);
34237 export function AcceptChannelV2_free(this_obj: bigint): void {
34238 if(!isWasmInitialized) {
34239 throw new Error("initializeWasm() must be awaited first!");
34241 const nativeResponseValue = wasm.TS_AcceptChannelV2_free(this_obj);
34242 // debug statements here
34244 // const uint8_t (*AcceptChannelV2_get_temporary_channel_id(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr))[32];
34246 export function AcceptChannelV2_get_temporary_channel_id(this_ptr: bigint): number {
34247 if(!isWasmInitialized) {
34248 throw new Error("initializeWasm() must be awaited first!");
34250 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_temporary_channel_id(this_ptr);
34251 return nativeResponseValue;
34253 // void AcceptChannelV2_set_temporary_channel_id(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34255 export function AcceptChannelV2_set_temporary_channel_id(this_ptr: bigint, val: number): void {
34256 if(!isWasmInitialized) {
34257 throw new Error("initializeWasm() must be awaited first!");
34259 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_temporary_channel_id(this_ptr, val);
34260 // debug statements here
34262 // uint64_t AcceptChannelV2_get_funding_satoshis(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34264 export function AcceptChannelV2_get_funding_satoshis(this_ptr: bigint): bigint {
34265 if(!isWasmInitialized) {
34266 throw new Error("initializeWasm() must be awaited first!");
34268 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_funding_satoshis(this_ptr);
34269 return nativeResponseValue;
34271 // void AcceptChannelV2_set_funding_satoshis(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
34273 export function AcceptChannelV2_set_funding_satoshis(this_ptr: bigint, val: bigint): void {
34274 if(!isWasmInitialized) {
34275 throw new Error("initializeWasm() must be awaited first!");
34277 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_funding_satoshis(this_ptr, val);
34278 // debug statements here
34280 // uint64_t AcceptChannelV2_get_dust_limit_satoshis(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34282 export function AcceptChannelV2_get_dust_limit_satoshis(this_ptr: bigint): bigint {
34283 if(!isWasmInitialized) {
34284 throw new Error("initializeWasm() must be awaited first!");
34286 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_dust_limit_satoshis(this_ptr);
34287 return nativeResponseValue;
34289 // void AcceptChannelV2_set_dust_limit_satoshis(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
34291 export function AcceptChannelV2_set_dust_limit_satoshis(this_ptr: bigint, val: bigint): void {
34292 if(!isWasmInitialized) {
34293 throw new Error("initializeWasm() must be awaited first!");
34295 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_dust_limit_satoshis(this_ptr, val);
34296 // debug statements here
34298 // uint64_t AcceptChannelV2_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34300 export function AcceptChannelV2_get_max_htlc_value_in_flight_msat(this_ptr: bigint): bigint {
34301 if(!isWasmInitialized) {
34302 throw new Error("initializeWasm() must be awaited first!");
34304 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_max_htlc_value_in_flight_msat(this_ptr);
34305 return nativeResponseValue;
34307 // void AcceptChannelV2_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
34309 export function AcceptChannelV2_set_max_htlc_value_in_flight_msat(this_ptr: bigint, val: bigint): void {
34310 if(!isWasmInitialized) {
34311 throw new Error("initializeWasm() must be awaited first!");
34313 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_max_htlc_value_in_flight_msat(this_ptr, val);
34314 // debug statements here
34316 // uint64_t AcceptChannelV2_get_htlc_minimum_msat(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34318 export function AcceptChannelV2_get_htlc_minimum_msat(this_ptr: bigint): bigint {
34319 if(!isWasmInitialized) {
34320 throw new Error("initializeWasm() must be awaited first!");
34322 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_htlc_minimum_msat(this_ptr);
34323 return nativeResponseValue;
34325 // void AcceptChannelV2_set_htlc_minimum_msat(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint64_t val);
34327 export function AcceptChannelV2_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
34328 if(!isWasmInitialized) {
34329 throw new Error("initializeWasm() must be awaited first!");
34331 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_htlc_minimum_msat(this_ptr, val);
34332 // debug statements here
34334 // uint32_t AcceptChannelV2_get_minimum_depth(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34336 export function AcceptChannelV2_get_minimum_depth(this_ptr: bigint): number {
34337 if(!isWasmInitialized) {
34338 throw new Error("initializeWasm() must be awaited first!");
34340 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_minimum_depth(this_ptr);
34341 return nativeResponseValue;
34343 // void AcceptChannelV2_set_minimum_depth(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint32_t val);
34345 export function AcceptChannelV2_set_minimum_depth(this_ptr: bigint, val: number): void {
34346 if(!isWasmInitialized) {
34347 throw new Error("initializeWasm() must be awaited first!");
34349 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_minimum_depth(this_ptr, val);
34350 // debug statements here
34352 // uint16_t AcceptChannelV2_get_to_self_delay(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34354 export function AcceptChannelV2_get_to_self_delay(this_ptr: bigint): number {
34355 if(!isWasmInitialized) {
34356 throw new Error("initializeWasm() must be awaited first!");
34358 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_to_self_delay(this_ptr);
34359 return nativeResponseValue;
34361 // void AcceptChannelV2_set_to_self_delay(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
34363 export function AcceptChannelV2_set_to_self_delay(this_ptr: bigint, val: number): void {
34364 if(!isWasmInitialized) {
34365 throw new Error("initializeWasm() must be awaited first!");
34367 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_to_self_delay(this_ptr, val);
34368 // debug statements here
34370 // uint16_t AcceptChannelV2_get_max_accepted_htlcs(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34372 export function AcceptChannelV2_get_max_accepted_htlcs(this_ptr: bigint): number {
34373 if(!isWasmInitialized) {
34374 throw new Error("initializeWasm() must be awaited first!");
34376 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_max_accepted_htlcs(this_ptr);
34377 return nativeResponseValue;
34379 // void AcceptChannelV2_set_max_accepted_htlcs(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, uint16_t val);
34381 export function AcceptChannelV2_set_max_accepted_htlcs(this_ptr: bigint, val: number): void {
34382 if(!isWasmInitialized) {
34383 throw new Error("initializeWasm() must be awaited first!");
34385 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_max_accepted_htlcs(this_ptr, val);
34386 // debug statements here
34388 // struct LDKPublicKey AcceptChannelV2_get_funding_pubkey(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34390 export function AcceptChannelV2_get_funding_pubkey(this_ptr: bigint): number {
34391 if(!isWasmInitialized) {
34392 throw new Error("initializeWasm() must be awaited first!");
34394 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_funding_pubkey(this_ptr);
34395 return nativeResponseValue;
34397 // void AcceptChannelV2_set_funding_pubkey(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34399 export function AcceptChannelV2_set_funding_pubkey(this_ptr: bigint, val: number): void {
34400 if(!isWasmInitialized) {
34401 throw new Error("initializeWasm() must be awaited first!");
34403 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_funding_pubkey(this_ptr, val);
34404 // debug statements here
34406 // struct LDKPublicKey AcceptChannelV2_get_revocation_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34408 export function AcceptChannelV2_get_revocation_basepoint(this_ptr: bigint): number {
34409 if(!isWasmInitialized) {
34410 throw new Error("initializeWasm() must be awaited first!");
34412 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_revocation_basepoint(this_ptr);
34413 return nativeResponseValue;
34415 // void AcceptChannelV2_set_revocation_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34417 export function AcceptChannelV2_set_revocation_basepoint(this_ptr: bigint, val: number): void {
34418 if(!isWasmInitialized) {
34419 throw new Error("initializeWasm() must be awaited first!");
34421 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_revocation_basepoint(this_ptr, val);
34422 // debug statements here
34424 // struct LDKPublicKey AcceptChannelV2_get_payment_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34426 export function AcceptChannelV2_get_payment_basepoint(this_ptr: bigint): number {
34427 if(!isWasmInitialized) {
34428 throw new Error("initializeWasm() must be awaited first!");
34430 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_payment_basepoint(this_ptr);
34431 return nativeResponseValue;
34433 // void AcceptChannelV2_set_payment_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34435 export function AcceptChannelV2_set_payment_basepoint(this_ptr: bigint, val: number): void {
34436 if(!isWasmInitialized) {
34437 throw new Error("initializeWasm() must be awaited first!");
34439 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_payment_basepoint(this_ptr, val);
34440 // debug statements here
34442 // struct LDKPublicKey AcceptChannelV2_get_delayed_payment_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34444 export function AcceptChannelV2_get_delayed_payment_basepoint(this_ptr: bigint): number {
34445 if(!isWasmInitialized) {
34446 throw new Error("initializeWasm() must be awaited first!");
34448 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_delayed_payment_basepoint(this_ptr);
34449 return nativeResponseValue;
34451 // void AcceptChannelV2_set_delayed_payment_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34453 export function AcceptChannelV2_set_delayed_payment_basepoint(this_ptr: bigint, val: number): void {
34454 if(!isWasmInitialized) {
34455 throw new Error("initializeWasm() must be awaited first!");
34457 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_delayed_payment_basepoint(this_ptr, val);
34458 // debug statements here
34460 // struct LDKPublicKey AcceptChannelV2_get_htlc_basepoint(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34462 export function AcceptChannelV2_get_htlc_basepoint(this_ptr: bigint): number {
34463 if(!isWasmInitialized) {
34464 throw new Error("initializeWasm() must be awaited first!");
34466 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_htlc_basepoint(this_ptr);
34467 return nativeResponseValue;
34469 // void AcceptChannelV2_set_htlc_basepoint(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34471 export function AcceptChannelV2_set_htlc_basepoint(this_ptr: bigint, val: number): void {
34472 if(!isWasmInitialized) {
34473 throw new Error("initializeWasm() must be awaited first!");
34475 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_htlc_basepoint(this_ptr, val);
34476 // debug statements here
34478 // struct LDKPublicKey AcceptChannelV2_get_first_per_commitment_point(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34480 export function AcceptChannelV2_get_first_per_commitment_point(this_ptr: bigint): number {
34481 if(!isWasmInitialized) {
34482 throw new Error("initializeWasm() must be awaited first!");
34484 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_first_per_commitment_point(this_ptr);
34485 return nativeResponseValue;
34487 // void AcceptChannelV2_set_first_per_commitment_point(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34489 export function AcceptChannelV2_set_first_per_commitment_point(this_ptr: bigint, val: number): void {
34490 if(!isWasmInitialized) {
34491 throw new Error("initializeWasm() must be awaited first!");
34493 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_first_per_commitment_point(this_ptr, val);
34494 // debug statements here
34496 // struct LDKPublicKey AcceptChannelV2_get_second_per_commitment_point(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34498 export function AcceptChannelV2_get_second_per_commitment_point(this_ptr: bigint): number {
34499 if(!isWasmInitialized) {
34500 throw new Error("initializeWasm() must be awaited first!");
34502 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_second_per_commitment_point(this_ptr);
34503 return nativeResponseValue;
34505 // void AcceptChannelV2_set_second_per_commitment_point(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34507 export function AcceptChannelV2_set_second_per_commitment_point(this_ptr: bigint, val: number): void {
34508 if(!isWasmInitialized) {
34509 throw new Error("initializeWasm() must be awaited first!");
34511 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_second_per_commitment_point(this_ptr, val);
34512 // debug statements here
34514 // struct LDKCOption_CVec_u8ZZ AcceptChannelV2_get_shutdown_scriptpubkey(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34516 export function AcceptChannelV2_get_shutdown_scriptpubkey(this_ptr: bigint): bigint {
34517 if(!isWasmInitialized) {
34518 throw new Error("initializeWasm() must be awaited first!");
34520 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_shutdown_scriptpubkey(this_ptr);
34521 return nativeResponseValue;
34523 // void AcceptChannelV2_set_shutdown_scriptpubkey(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
34525 export function AcceptChannelV2_set_shutdown_scriptpubkey(this_ptr: bigint, val: bigint): void {
34526 if(!isWasmInitialized) {
34527 throw new Error("initializeWasm() must be awaited first!");
34529 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_shutdown_scriptpubkey(this_ptr, val);
34530 // debug statements here
34532 // struct LDKChannelTypeFeatures AcceptChannelV2_get_channel_type(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34534 export function AcceptChannelV2_get_channel_type(this_ptr: bigint): bigint {
34535 if(!isWasmInitialized) {
34536 throw new Error("initializeWasm() must be awaited first!");
34538 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_channel_type(this_ptr);
34539 return nativeResponseValue;
34541 // void AcceptChannelV2_set_channel_type(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
34543 export function AcceptChannelV2_set_channel_type(this_ptr: bigint, val: bigint): void {
34544 if(!isWasmInitialized) {
34545 throw new Error("initializeWasm() must be awaited first!");
34547 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_channel_type(this_ptr, val);
34548 // debug statements here
34550 // enum LDKCOption_NoneZ AcceptChannelV2_get_require_confirmed_inputs(const struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr);
34552 export function AcceptChannelV2_get_require_confirmed_inputs(this_ptr: bigint): COption_NoneZ {
34553 if(!isWasmInitialized) {
34554 throw new Error("initializeWasm() must be awaited first!");
34556 const nativeResponseValue = wasm.TS_AcceptChannelV2_get_require_confirmed_inputs(this_ptr);
34557 return nativeResponseValue;
34559 // void AcceptChannelV2_set_require_confirmed_inputs(struct LDKAcceptChannelV2 *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
34561 export function AcceptChannelV2_set_require_confirmed_inputs(this_ptr: bigint, val: COption_NoneZ): void {
34562 if(!isWasmInitialized) {
34563 throw new Error("initializeWasm() must be awaited first!");
34565 const nativeResponseValue = wasm.TS_AcceptChannelV2_set_require_confirmed_inputs(this_ptr, val);
34566 // debug statements here
34568 // 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);
34570 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 {
34571 if(!isWasmInitialized) {
34572 throw new Error("initializeWasm() must be awaited first!");
34574 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);
34575 return nativeResponseValue;
34577 // uint64_t AcceptChannelV2_clone_ptr(LDKAcceptChannelV2 *NONNULL_PTR arg);
34579 export function AcceptChannelV2_clone_ptr(arg: bigint): bigint {
34580 if(!isWasmInitialized) {
34581 throw new Error("initializeWasm() must be awaited first!");
34583 const nativeResponseValue = wasm.TS_AcceptChannelV2_clone_ptr(arg);
34584 return nativeResponseValue;
34586 // struct LDKAcceptChannelV2 AcceptChannelV2_clone(const struct LDKAcceptChannelV2 *NONNULL_PTR orig);
34588 export function AcceptChannelV2_clone(orig: bigint): bigint {
34589 if(!isWasmInitialized) {
34590 throw new Error("initializeWasm() must be awaited first!");
34592 const nativeResponseValue = wasm.TS_AcceptChannelV2_clone(orig);
34593 return nativeResponseValue;
34595 // uint64_t AcceptChannelV2_hash(const struct LDKAcceptChannelV2 *NONNULL_PTR o);
34597 export function AcceptChannelV2_hash(o: bigint): bigint {
34598 if(!isWasmInitialized) {
34599 throw new Error("initializeWasm() must be awaited first!");
34601 const nativeResponseValue = wasm.TS_AcceptChannelV2_hash(o);
34602 return nativeResponseValue;
34604 // bool AcceptChannelV2_eq(const struct LDKAcceptChannelV2 *NONNULL_PTR a, const struct LDKAcceptChannelV2 *NONNULL_PTR b);
34606 export function AcceptChannelV2_eq(a: bigint, b: bigint): boolean {
34607 if(!isWasmInitialized) {
34608 throw new Error("initializeWasm() must be awaited first!");
34610 const nativeResponseValue = wasm.TS_AcceptChannelV2_eq(a, b);
34611 return nativeResponseValue;
34613 // void FundingCreated_free(struct LDKFundingCreated this_obj);
34615 export function FundingCreated_free(this_obj: bigint): void {
34616 if(!isWasmInitialized) {
34617 throw new Error("initializeWasm() must be awaited first!");
34619 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
34620 // debug statements here
34622 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
34624 export function FundingCreated_get_temporary_channel_id(this_ptr: bigint): number {
34625 if(!isWasmInitialized) {
34626 throw new Error("initializeWasm() must be awaited first!");
34628 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
34629 return nativeResponseValue;
34631 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34633 export function FundingCreated_set_temporary_channel_id(this_ptr: bigint, val: number): void {
34634 if(!isWasmInitialized) {
34635 throw new Error("initializeWasm() must be awaited first!");
34637 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
34638 // debug statements here
34640 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
34642 export function FundingCreated_get_funding_txid(this_ptr: bigint): number {
34643 if(!isWasmInitialized) {
34644 throw new Error("initializeWasm() must be awaited first!");
34646 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
34647 return nativeResponseValue;
34649 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34651 export function FundingCreated_set_funding_txid(this_ptr: bigint, val: number): void {
34652 if(!isWasmInitialized) {
34653 throw new Error("initializeWasm() must be awaited first!");
34655 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
34656 // debug statements here
34658 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
34660 export function FundingCreated_get_funding_output_index(this_ptr: bigint): number {
34661 if(!isWasmInitialized) {
34662 throw new Error("initializeWasm() must be awaited first!");
34664 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
34665 return nativeResponseValue;
34667 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
34669 export function FundingCreated_set_funding_output_index(this_ptr: bigint, val: number): void {
34670 if(!isWasmInitialized) {
34671 throw new Error("initializeWasm() must be awaited first!");
34673 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
34674 // debug statements here
34676 // struct LDKECDSASignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
34678 export function FundingCreated_get_signature(this_ptr: bigint): number {
34679 if(!isWasmInitialized) {
34680 throw new Error("initializeWasm() must be awaited first!");
34682 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
34683 return nativeResponseValue;
34685 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34687 export function FundingCreated_set_signature(this_ptr: bigint, val: number): void {
34688 if(!isWasmInitialized) {
34689 throw new Error("initializeWasm() must be awaited first!");
34691 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
34692 // debug statements here
34694 // 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);
34696 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): bigint {
34697 if(!isWasmInitialized) {
34698 throw new Error("initializeWasm() must be awaited first!");
34700 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
34701 return nativeResponseValue;
34703 // uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
34705 export function FundingCreated_clone_ptr(arg: bigint): bigint {
34706 if(!isWasmInitialized) {
34707 throw new Error("initializeWasm() must be awaited first!");
34709 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
34710 return nativeResponseValue;
34712 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
34714 export function FundingCreated_clone(orig: bigint): bigint {
34715 if(!isWasmInitialized) {
34716 throw new Error("initializeWasm() must be awaited first!");
34718 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
34719 return nativeResponseValue;
34721 // uint64_t FundingCreated_hash(const struct LDKFundingCreated *NONNULL_PTR o);
34723 export function FundingCreated_hash(o: bigint): bigint {
34724 if(!isWasmInitialized) {
34725 throw new Error("initializeWasm() must be awaited first!");
34727 const nativeResponseValue = wasm.TS_FundingCreated_hash(o);
34728 return nativeResponseValue;
34730 // bool FundingCreated_eq(const struct LDKFundingCreated *NONNULL_PTR a, const struct LDKFundingCreated *NONNULL_PTR b);
34732 export function FundingCreated_eq(a: bigint, b: bigint): boolean {
34733 if(!isWasmInitialized) {
34734 throw new Error("initializeWasm() must be awaited first!");
34736 const nativeResponseValue = wasm.TS_FundingCreated_eq(a, b);
34737 return nativeResponseValue;
34739 // void FundingSigned_free(struct LDKFundingSigned this_obj);
34741 export function FundingSigned_free(this_obj: bigint): void {
34742 if(!isWasmInitialized) {
34743 throw new Error("initializeWasm() must be awaited first!");
34745 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
34746 // debug statements here
34748 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
34750 export function FundingSigned_get_channel_id(this_ptr: bigint): number {
34751 if(!isWasmInitialized) {
34752 throw new Error("initializeWasm() must be awaited first!");
34754 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
34755 return nativeResponseValue;
34757 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34759 export function FundingSigned_set_channel_id(this_ptr: bigint, val: number): void {
34760 if(!isWasmInitialized) {
34761 throw new Error("initializeWasm() must be awaited first!");
34763 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
34764 // debug statements here
34766 // struct LDKECDSASignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
34768 export function FundingSigned_get_signature(this_ptr: bigint): number {
34769 if(!isWasmInitialized) {
34770 throw new Error("initializeWasm() must be awaited first!");
34772 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
34773 return nativeResponseValue;
34775 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
34777 export function FundingSigned_set_signature(this_ptr: bigint, val: number): void {
34778 if(!isWasmInitialized) {
34779 throw new Error("initializeWasm() must be awaited first!");
34781 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
34782 // debug statements here
34784 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKECDSASignature signature_arg);
34786 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): bigint {
34787 if(!isWasmInitialized) {
34788 throw new Error("initializeWasm() must be awaited first!");
34790 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
34791 return nativeResponseValue;
34793 // uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
34795 export function FundingSigned_clone_ptr(arg: bigint): bigint {
34796 if(!isWasmInitialized) {
34797 throw new Error("initializeWasm() must be awaited first!");
34799 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
34800 return nativeResponseValue;
34802 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
34804 export function FundingSigned_clone(orig: bigint): bigint {
34805 if(!isWasmInitialized) {
34806 throw new Error("initializeWasm() must be awaited first!");
34808 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
34809 return nativeResponseValue;
34811 // uint64_t FundingSigned_hash(const struct LDKFundingSigned *NONNULL_PTR o);
34813 export function FundingSigned_hash(o: bigint): bigint {
34814 if(!isWasmInitialized) {
34815 throw new Error("initializeWasm() must be awaited first!");
34817 const nativeResponseValue = wasm.TS_FundingSigned_hash(o);
34818 return nativeResponseValue;
34820 // bool FundingSigned_eq(const struct LDKFundingSigned *NONNULL_PTR a, const struct LDKFundingSigned *NONNULL_PTR b);
34822 export function FundingSigned_eq(a: bigint, b: bigint): boolean {
34823 if(!isWasmInitialized) {
34824 throw new Error("initializeWasm() must be awaited first!");
34826 const nativeResponseValue = wasm.TS_FundingSigned_eq(a, b);
34827 return nativeResponseValue;
34829 // void ChannelReady_free(struct LDKChannelReady this_obj);
34831 export function ChannelReady_free(this_obj: bigint): void {
34832 if(!isWasmInitialized) {
34833 throw new Error("initializeWasm() must be awaited first!");
34835 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
34836 // debug statements here
34838 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
34840 export function ChannelReady_get_channel_id(this_ptr: bigint): number {
34841 if(!isWasmInitialized) {
34842 throw new Error("initializeWasm() must be awaited first!");
34844 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
34845 return nativeResponseValue;
34847 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34849 export function ChannelReady_set_channel_id(this_ptr: bigint, val: number): void {
34850 if(!isWasmInitialized) {
34851 throw new Error("initializeWasm() must be awaited first!");
34853 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
34854 // debug statements here
34856 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
34858 export function ChannelReady_get_next_per_commitment_point(this_ptr: bigint): number {
34859 if(!isWasmInitialized) {
34860 throw new Error("initializeWasm() must be awaited first!");
34862 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
34863 return nativeResponseValue;
34865 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
34867 export function ChannelReady_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
34868 if(!isWasmInitialized) {
34869 throw new Error("initializeWasm() must be awaited first!");
34871 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
34872 // debug statements here
34874 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
34876 export function ChannelReady_get_short_channel_id_alias(this_ptr: bigint): bigint {
34877 if(!isWasmInitialized) {
34878 throw new Error("initializeWasm() must be awaited first!");
34880 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
34881 return nativeResponseValue;
34883 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
34885 export function ChannelReady_set_short_channel_id_alias(this_ptr: bigint, val: bigint): void {
34886 if(!isWasmInitialized) {
34887 throw new Error("initializeWasm() must be awaited first!");
34889 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
34890 // debug statements here
34892 // 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);
34894 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: bigint): bigint {
34895 if(!isWasmInitialized) {
34896 throw new Error("initializeWasm() must be awaited first!");
34898 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
34899 return nativeResponseValue;
34901 // uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
34903 export function ChannelReady_clone_ptr(arg: bigint): bigint {
34904 if(!isWasmInitialized) {
34905 throw new Error("initializeWasm() must be awaited first!");
34907 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
34908 return nativeResponseValue;
34910 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
34912 export function ChannelReady_clone(orig: bigint): bigint {
34913 if(!isWasmInitialized) {
34914 throw new Error("initializeWasm() must be awaited first!");
34916 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
34917 return nativeResponseValue;
34919 // uint64_t ChannelReady_hash(const struct LDKChannelReady *NONNULL_PTR o);
34921 export function ChannelReady_hash(o: bigint): bigint {
34922 if(!isWasmInitialized) {
34923 throw new Error("initializeWasm() must be awaited first!");
34925 const nativeResponseValue = wasm.TS_ChannelReady_hash(o);
34926 return nativeResponseValue;
34928 // bool ChannelReady_eq(const struct LDKChannelReady *NONNULL_PTR a, const struct LDKChannelReady *NONNULL_PTR b);
34930 export function ChannelReady_eq(a: bigint, b: bigint): boolean {
34931 if(!isWasmInitialized) {
34932 throw new Error("initializeWasm() must be awaited first!");
34934 const nativeResponseValue = wasm.TS_ChannelReady_eq(a, b);
34935 return nativeResponseValue;
34937 // void Stfu_free(struct LDKStfu this_obj);
34939 export function Stfu_free(this_obj: bigint): void {
34940 if(!isWasmInitialized) {
34941 throw new Error("initializeWasm() must be awaited first!");
34943 const nativeResponseValue = wasm.TS_Stfu_free(this_obj);
34944 // debug statements here
34946 // const uint8_t (*Stfu_get_channel_id(const struct LDKStfu *NONNULL_PTR this_ptr))[32];
34948 export function Stfu_get_channel_id(this_ptr: bigint): number {
34949 if(!isWasmInitialized) {
34950 throw new Error("initializeWasm() must be awaited first!");
34952 const nativeResponseValue = wasm.TS_Stfu_get_channel_id(this_ptr);
34953 return nativeResponseValue;
34955 // void Stfu_set_channel_id(struct LDKStfu *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
34957 export function Stfu_set_channel_id(this_ptr: bigint, val: number): void {
34958 if(!isWasmInitialized) {
34959 throw new Error("initializeWasm() must be awaited first!");
34961 const nativeResponseValue = wasm.TS_Stfu_set_channel_id(this_ptr, val);
34962 // debug statements here
34964 // uint8_t Stfu_get_initiator(const struct LDKStfu *NONNULL_PTR this_ptr);
34966 export function Stfu_get_initiator(this_ptr: bigint): number {
34967 if(!isWasmInitialized) {
34968 throw new Error("initializeWasm() must be awaited first!");
34970 const nativeResponseValue = wasm.TS_Stfu_get_initiator(this_ptr);
34971 return nativeResponseValue;
34973 // void Stfu_set_initiator(struct LDKStfu *NONNULL_PTR this_ptr, uint8_t val);
34975 export function Stfu_set_initiator(this_ptr: bigint, val: number): void {
34976 if(!isWasmInitialized) {
34977 throw new Error("initializeWasm() must be awaited first!");
34979 const nativeResponseValue = wasm.TS_Stfu_set_initiator(this_ptr, val);
34980 // debug statements here
34982 // MUST_USE_RES struct LDKStfu Stfu_new(struct LDKThirtyTwoBytes channel_id_arg, uint8_t initiator_arg);
34984 export function Stfu_new(channel_id_arg: number, initiator_arg: number): bigint {
34985 if(!isWasmInitialized) {
34986 throw new Error("initializeWasm() must be awaited first!");
34988 const nativeResponseValue = wasm.TS_Stfu_new(channel_id_arg, initiator_arg);
34989 return nativeResponseValue;
34991 // uint64_t Stfu_clone_ptr(LDKStfu *NONNULL_PTR arg);
34993 export function Stfu_clone_ptr(arg: bigint): bigint {
34994 if(!isWasmInitialized) {
34995 throw new Error("initializeWasm() must be awaited first!");
34997 const nativeResponseValue = wasm.TS_Stfu_clone_ptr(arg);
34998 return nativeResponseValue;
35000 // struct LDKStfu Stfu_clone(const struct LDKStfu *NONNULL_PTR orig);
35002 export function Stfu_clone(orig: bigint): bigint {
35003 if(!isWasmInitialized) {
35004 throw new Error("initializeWasm() must be awaited first!");
35006 const nativeResponseValue = wasm.TS_Stfu_clone(orig);
35007 return nativeResponseValue;
35009 // bool Stfu_eq(const struct LDKStfu *NONNULL_PTR a, const struct LDKStfu *NONNULL_PTR b);
35011 export function Stfu_eq(a: bigint, b: bigint): boolean {
35012 if(!isWasmInitialized) {
35013 throw new Error("initializeWasm() must be awaited first!");
35015 const nativeResponseValue = wasm.TS_Stfu_eq(a, b);
35016 return nativeResponseValue;
35018 // void Splice_free(struct LDKSplice this_obj);
35020 export function Splice_free(this_obj: bigint): void {
35021 if(!isWasmInitialized) {
35022 throw new Error("initializeWasm() must be awaited first!");
35024 const nativeResponseValue = wasm.TS_Splice_free(this_obj);
35025 // debug statements here
35027 // const uint8_t (*Splice_get_channel_id(const struct LDKSplice *NONNULL_PTR this_ptr))[32];
35029 export function Splice_get_channel_id(this_ptr: bigint): number {
35030 if(!isWasmInitialized) {
35031 throw new Error("initializeWasm() must be awaited first!");
35033 const nativeResponseValue = wasm.TS_Splice_get_channel_id(this_ptr);
35034 return nativeResponseValue;
35036 // void Splice_set_channel_id(struct LDKSplice *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35038 export function Splice_set_channel_id(this_ptr: bigint, val: number): void {
35039 if(!isWasmInitialized) {
35040 throw new Error("initializeWasm() must be awaited first!");
35042 const nativeResponseValue = wasm.TS_Splice_set_channel_id(this_ptr, val);
35043 // debug statements here
35045 // const uint8_t (*Splice_get_chain_hash(const struct LDKSplice *NONNULL_PTR this_ptr))[32];
35047 export function Splice_get_chain_hash(this_ptr: bigint): number {
35048 if(!isWasmInitialized) {
35049 throw new Error("initializeWasm() must be awaited first!");
35051 const nativeResponseValue = wasm.TS_Splice_get_chain_hash(this_ptr);
35052 return nativeResponseValue;
35054 // void Splice_set_chain_hash(struct LDKSplice *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35056 export function Splice_set_chain_hash(this_ptr: bigint, val: number): void {
35057 if(!isWasmInitialized) {
35058 throw new Error("initializeWasm() must be awaited first!");
35060 const nativeResponseValue = wasm.TS_Splice_set_chain_hash(this_ptr, val);
35061 // debug statements here
35063 // int64_t Splice_get_relative_satoshis(const struct LDKSplice *NONNULL_PTR this_ptr);
35065 export function Splice_get_relative_satoshis(this_ptr: bigint): bigint {
35066 if(!isWasmInitialized) {
35067 throw new Error("initializeWasm() must be awaited first!");
35069 const nativeResponseValue = wasm.TS_Splice_get_relative_satoshis(this_ptr);
35070 return nativeResponseValue;
35072 // void Splice_set_relative_satoshis(struct LDKSplice *NONNULL_PTR this_ptr, int64_t val);
35074 export function Splice_set_relative_satoshis(this_ptr: bigint, val: bigint): void {
35075 if(!isWasmInitialized) {
35076 throw new Error("initializeWasm() must be awaited first!");
35078 const nativeResponseValue = wasm.TS_Splice_set_relative_satoshis(this_ptr, val);
35079 // debug statements here
35081 // uint32_t Splice_get_funding_feerate_perkw(const struct LDKSplice *NONNULL_PTR this_ptr);
35083 export function Splice_get_funding_feerate_perkw(this_ptr: bigint): number {
35084 if(!isWasmInitialized) {
35085 throw new Error("initializeWasm() must be awaited first!");
35087 const nativeResponseValue = wasm.TS_Splice_get_funding_feerate_perkw(this_ptr);
35088 return nativeResponseValue;
35090 // void Splice_set_funding_feerate_perkw(struct LDKSplice *NONNULL_PTR this_ptr, uint32_t val);
35092 export function Splice_set_funding_feerate_perkw(this_ptr: bigint, val: number): void {
35093 if(!isWasmInitialized) {
35094 throw new Error("initializeWasm() must be awaited first!");
35096 const nativeResponseValue = wasm.TS_Splice_set_funding_feerate_perkw(this_ptr, val);
35097 // debug statements here
35099 // uint32_t Splice_get_locktime(const struct LDKSplice *NONNULL_PTR this_ptr);
35101 export function Splice_get_locktime(this_ptr: bigint): number {
35102 if(!isWasmInitialized) {
35103 throw new Error("initializeWasm() must be awaited first!");
35105 const nativeResponseValue = wasm.TS_Splice_get_locktime(this_ptr);
35106 return nativeResponseValue;
35108 // void Splice_set_locktime(struct LDKSplice *NONNULL_PTR this_ptr, uint32_t val);
35110 export function Splice_set_locktime(this_ptr: bigint, val: number): void {
35111 if(!isWasmInitialized) {
35112 throw new Error("initializeWasm() must be awaited first!");
35114 const nativeResponseValue = wasm.TS_Splice_set_locktime(this_ptr, val);
35115 // debug statements here
35117 // struct LDKPublicKey Splice_get_funding_pubkey(const struct LDKSplice *NONNULL_PTR this_ptr);
35119 export function Splice_get_funding_pubkey(this_ptr: bigint): number {
35120 if(!isWasmInitialized) {
35121 throw new Error("initializeWasm() must be awaited first!");
35123 const nativeResponseValue = wasm.TS_Splice_get_funding_pubkey(this_ptr);
35124 return nativeResponseValue;
35126 // void Splice_set_funding_pubkey(struct LDKSplice *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35128 export function Splice_set_funding_pubkey(this_ptr: bigint, val: number): void {
35129 if(!isWasmInitialized) {
35130 throw new Error("initializeWasm() must be awaited first!");
35132 const nativeResponseValue = wasm.TS_Splice_set_funding_pubkey(this_ptr, val);
35133 // debug statements here
35135 // MUST_USE_RES struct LDKSplice Splice_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKThirtyTwoBytes chain_hash_arg, int64_t relative_satoshis_arg, uint32_t funding_feerate_perkw_arg, uint32_t locktime_arg, struct LDKPublicKey funding_pubkey_arg);
35137 export function Splice_new(channel_id_arg: number, chain_hash_arg: number, relative_satoshis_arg: bigint, funding_feerate_perkw_arg: number, locktime_arg: number, funding_pubkey_arg: number): bigint {
35138 if(!isWasmInitialized) {
35139 throw new Error("initializeWasm() must be awaited first!");
35141 const nativeResponseValue = wasm.TS_Splice_new(channel_id_arg, chain_hash_arg, relative_satoshis_arg, funding_feerate_perkw_arg, locktime_arg, funding_pubkey_arg);
35142 return nativeResponseValue;
35144 // uint64_t Splice_clone_ptr(LDKSplice *NONNULL_PTR arg);
35146 export function Splice_clone_ptr(arg: bigint): bigint {
35147 if(!isWasmInitialized) {
35148 throw new Error("initializeWasm() must be awaited first!");
35150 const nativeResponseValue = wasm.TS_Splice_clone_ptr(arg);
35151 return nativeResponseValue;
35153 // struct LDKSplice Splice_clone(const struct LDKSplice *NONNULL_PTR orig);
35155 export function Splice_clone(orig: bigint): bigint {
35156 if(!isWasmInitialized) {
35157 throw new Error("initializeWasm() must be awaited first!");
35159 const nativeResponseValue = wasm.TS_Splice_clone(orig);
35160 return nativeResponseValue;
35162 // bool Splice_eq(const struct LDKSplice *NONNULL_PTR a, const struct LDKSplice *NONNULL_PTR b);
35164 export function Splice_eq(a: bigint, b: bigint): boolean {
35165 if(!isWasmInitialized) {
35166 throw new Error("initializeWasm() must be awaited first!");
35168 const nativeResponseValue = wasm.TS_Splice_eq(a, b);
35169 return nativeResponseValue;
35171 // void SpliceAck_free(struct LDKSpliceAck this_obj);
35173 export function SpliceAck_free(this_obj: bigint): void {
35174 if(!isWasmInitialized) {
35175 throw new Error("initializeWasm() must be awaited first!");
35177 const nativeResponseValue = wasm.TS_SpliceAck_free(this_obj);
35178 // debug statements here
35180 // const uint8_t (*SpliceAck_get_channel_id(const struct LDKSpliceAck *NONNULL_PTR this_ptr))[32];
35182 export function SpliceAck_get_channel_id(this_ptr: bigint): number {
35183 if(!isWasmInitialized) {
35184 throw new Error("initializeWasm() must be awaited first!");
35186 const nativeResponseValue = wasm.TS_SpliceAck_get_channel_id(this_ptr);
35187 return nativeResponseValue;
35189 // void SpliceAck_set_channel_id(struct LDKSpliceAck *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35191 export function SpliceAck_set_channel_id(this_ptr: bigint, val: number): void {
35192 if(!isWasmInitialized) {
35193 throw new Error("initializeWasm() must be awaited first!");
35195 const nativeResponseValue = wasm.TS_SpliceAck_set_channel_id(this_ptr, val);
35196 // debug statements here
35198 // const uint8_t (*SpliceAck_get_chain_hash(const struct LDKSpliceAck *NONNULL_PTR this_ptr))[32];
35200 export function SpliceAck_get_chain_hash(this_ptr: bigint): number {
35201 if(!isWasmInitialized) {
35202 throw new Error("initializeWasm() must be awaited first!");
35204 const nativeResponseValue = wasm.TS_SpliceAck_get_chain_hash(this_ptr);
35205 return nativeResponseValue;
35207 // void SpliceAck_set_chain_hash(struct LDKSpliceAck *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35209 export function SpliceAck_set_chain_hash(this_ptr: bigint, val: number): void {
35210 if(!isWasmInitialized) {
35211 throw new Error("initializeWasm() must be awaited first!");
35213 const nativeResponseValue = wasm.TS_SpliceAck_set_chain_hash(this_ptr, val);
35214 // debug statements here
35216 // int64_t SpliceAck_get_relative_satoshis(const struct LDKSpliceAck *NONNULL_PTR this_ptr);
35218 export function SpliceAck_get_relative_satoshis(this_ptr: bigint): bigint {
35219 if(!isWasmInitialized) {
35220 throw new Error("initializeWasm() must be awaited first!");
35222 const nativeResponseValue = wasm.TS_SpliceAck_get_relative_satoshis(this_ptr);
35223 return nativeResponseValue;
35225 // void SpliceAck_set_relative_satoshis(struct LDKSpliceAck *NONNULL_PTR this_ptr, int64_t val);
35227 export function SpliceAck_set_relative_satoshis(this_ptr: bigint, val: bigint): void {
35228 if(!isWasmInitialized) {
35229 throw new Error("initializeWasm() must be awaited first!");
35231 const nativeResponseValue = wasm.TS_SpliceAck_set_relative_satoshis(this_ptr, val);
35232 // debug statements here
35234 // struct LDKPublicKey SpliceAck_get_funding_pubkey(const struct LDKSpliceAck *NONNULL_PTR this_ptr);
35236 export function SpliceAck_get_funding_pubkey(this_ptr: bigint): number {
35237 if(!isWasmInitialized) {
35238 throw new Error("initializeWasm() must be awaited first!");
35240 const nativeResponseValue = wasm.TS_SpliceAck_get_funding_pubkey(this_ptr);
35241 return nativeResponseValue;
35243 // void SpliceAck_set_funding_pubkey(struct LDKSpliceAck *NONNULL_PTR this_ptr, struct LDKPublicKey val);
35245 export function SpliceAck_set_funding_pubkey(this_ptr: bigint, val: number): void {
35246 if(!isWasmInitialized) {
35247 throw new Error("initializeWasm() must be awaited first!");
35249 const nativeResponseValue = wasm.TS_SpliceAck_set_funding_pubkey(this_ptr, val);
35250 // debug statements here
35252 // MUST_USE_RES struct LDKSpliceAck SpliceAck_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKThirtyTwoBytes chain_hash_arg, int64_t relative_satoshis_arg, struct LDKPublicKey funding_pubkey_arg);
35254 export function SpliceAck_new(channel_id_arg: number, chain_hash_arg: number, relative_satoshis_arg: bigint, funding_pubkey_arg: number): bigint {
35255 if(!isWasmInitialized) {
35256 throw new Error("initializeWasm() must be awaited first!");
35258 const nativeResponseValue = wasm.TS_SpliceAck_new(channel_id_arg, chain_hash_arg, relative_satoshis_arg, funding_pubkey_arg);
35259 return nativeResponseValue;
35261 // uint64_t SpliceAck_clone_ptr(LDKSpliceAck *NONNULL_PTR arg);
35263 export function SpliceAck_clone_ptr(arg: bigint): bigint {
35264 if(!isWasmInitialized) {
35265 throw new Error("initializeWasm() must be awaited first!");
35267 const nativeResponseValue = wasm.TS_SpliceAck_clone_ptr(arg);
35268 return nativeResponseValue;
35270 // struct LDKSpliceAck SpliceAck_clone(const struct LDKSpliceAck *NONNULL_PTR orig);
35272 export function SpliceAck_clone(orig: bigint): bigint {
35273 if(!isWasmInitialized) {
35274 throw new Error("initializeWasm() must be awaited first!");
35276 const nativeResponseValue = wasm.TS_SpliceAck_clone(orig);
35277 return nativeResponseValue;
35279 // bool SpliceAck_eq(const struct LDKSpliceAck *NONNULL_PTR a, const struct LDKSpliceAck *NONNULL_PTR b);
35281 export function SpliceAck_eq(a: bigint, b: bigint): boolean {
35282 if(!isWasmInitialized) {
35283 throw new Error("initializeWasm() must be awaited first!");
35285 const nativeResponseValue = wasm.TS_SpliceAck_eq(a, b);
35286 return nativeResponseValue;
35288 // void SpliceLocked_free(struct LDKSpliceLocked this_obj);
35290 export function SpliceLocked_free(this_obj: bigint): void {
35291 if(!isWasmInitialized) {
35292 throw new Error("initializeWasm() must be awaited first!");
35294 const nativeResponseValue = wasm.TS_SpliceLocked_free(this_obj);
35295 // debug statements here
35297 // const uint8_t (*SpliceLocked_get_channel_id(const struct LDKSpliceLocked *NONNULL_PTR this_ptr))[32];
35299 export function SpliceLocked_get_channel_id(this_ptr: bigint): number {
35300 if(!isWasmInitialized) {
35301 throw new Error("initializeWasm() must be awaited first!");
35303 const nativeResponseValue = wasm.TS_SpliceLocked_get_channel_id(this_ptr);
35304 return nativeResponseValue;
35306 // void SpliceLocked_set_channel_id(struct LDKSpliceLocked *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35308 export function SpliceLocked_set_channel_id(this_ptr: bigint, val: number): void {
35309 if(!isWasmInitialized) {
35310 throw new Error("initializeWasm() must be awaited first!");
35312 const nativeResponseValue = wasm.TS_SpliceLocked_set_channel_id(this_ptr, val);
35313 // debug statements here
35315 // MUST_USE_RES struct LDKSpliceLocked SpliceLocked_new(struct LDKThirtyTwoBytes channel_id_arg);
35317 export function SpliceLocked_new(channel_id_arg: number): bigint {
35318 if(!isWasmInitialized) {
35319 throw new Error("initializeWasm() must be awaited first!");
35321 const nativeResponseValue = wasm.TS_SpliceLocked_new(channel_id_arg);
35322 return nativeResponseValue;
35324 // uint64_t SpliceLocked_clone_ptr(LDKSpliceLocked *NONNULL_PTR arg);
35326 export function SpliceLocked_clone_ptr(arg: bigint): bigint {
35327 if(!isWasmInitialized) {
35328 throw new Error("initializeWasm() must be awaited first!");
35330 const nativeResponseValue = wasm.TS_SpliceLocked_clone_ptr(arg);
35331 return nativeResponseValue;
35333 // struct LDKSpliceLocked SpliceLocked_clone(const struct LDKSpliceLocked *NONNULL_PTR orig);
35335 export function SpliceLocked_clone(orig: bigint): bigint {
35336 if(!isWasmInitialized) {
35337 throw new Error("initializeWasm() must be awaited first!");
35339 const nativeResponseValue = wasm.TS_SpliceLocked_clone(orig);
35340 return nativeResponseValue;
35342 // bool SpliceLocked_eq(const struct LDKSpliceLocked *NONNULL_PTR a, const struct LDKSpliceLocked *NONNULL_PTR b);
35344 export function SpliceLocked_eq(a: bigint, b: bigint): boolean {
35345 if(!isWasmInitialized) {
35346 throw new Error("initializeWasm() must be awaited first!");
35348 const nativeResponseValue = wasm.TS_SpliceLocked_eq(a, b);
35349 return nativeResponseValue;
35351 // void TxAddInput_free(struct LDKTxAddInput this_obj);
35353 export function TxAddInput_free(this_obj: bigint): void {
35354 if(!isWasmInitialized) {
35355 throw new Error("initializeWasm() must be awaited first!");
35357 const nativeResponseValue = wasm.TS_TxAddInput_free(this_obj);
35358 // debug statements here
35360 // const uint8_t (*TxAddInput_get_channel_id(const struct LDKTxAddInput *NONNULL_PTR this_ptr))[32];
35362 export function TxAddInput_get_channel_id(this_ptr: bigint): number {
35363 if(!isWasmInitialized) {
35364 throw new Error("initializeWasm() must be awaited first!");
35366 const nativeResponseValue = wasm.TS_TxAddInput_get_channel_id(this_ptr);
35367 return nativeResponseValue;
35369 // void TxAddInput_set_channel_id(struct LDKTxAddInput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35371 export function TxAddInput_set_channel_id(this_ptr: bigint, val: number): void {
35372 if(!isWasmInitialized) {
35373 throw new Error("initializeWasm() must be awaited first!");
35375 const nativeResponseValue = wasm.TS_TxAddInput_set_channel_id(this_ptr, val);
35376 // debug statements here
35378 // uint64_t TxAddInput_get_serial_id(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
35380 export function TxAddInput_get_serial_id(this_ptr: bigint): bigint {
35381 if(!isWasmInitialized) {
35382 throw new Error("initializeWasm() must be awaited first!");
35384 const nativeResponseValue = wasm.TS_TxAddInput_get_serial_id(this_ptr);
35385 return nativeResponseValue;
35387 // void TxAddInput_set_serial_id(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint64_t val);
35389 export function TxAddInput_set_serial_id(this_ptr: bigint, val: bigint): void {
35390 if(!isWasmInitialized) {
35391 throw new Error("initializeWasm() must be awaited first!");
35393 const nativeResponseValue = wasm.TS_TxAddInput_set_serial_id(this_ptr, val);
35394 // debug statements here
35396 // struct LDKTransactionU16LenLimited TxAddInput_get_prevtx(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
35398 export function TxAddInput_get_prevtx(this_ptr: bigint): bigint {
35399 if(!isWasmInitialized) {
35400 throw new Error("initializeWasm() must be awaited first!");
35402 const nativeResponseValue = wasm.TS_TxAddInput_get_prevtx(this_ptr);
35403 return nativeResponseValue;
35405 // void TxAddInput_set_prevtx(struct LDKTxAddInput *NONNULL_PTR this_ptr, struct LDKTransactionU16LenLimited val);
35407 export function TxAddInput_set_prevtx(this_ptr: bigint, val: bigint): void {
35408 if(!isWasmInitialized) {
35409 throw new Error("initializeWasm() must be awaited first!");
35411 const nativeResponseValue = wasm.TS_TxAddInput_set_prevtx(this_ptr, val);
35412 // debug statements here
35414 // uint32_t TxAddInput_get_prevtx_out(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
35416 export function TxAddInput_get_prevtx_out(this_ptr: bigint): number {
35417 if(!isWasmInitialized) {
35418 throw new Error("initializeWasm() must be awaited first!");
35420 const nativeResponseValue = wasm.TS_TxAddInput_get_prevtx_out(this_ptr);
35421 return nativeResponseValue;
35423 // void TxAddInput_set_prevtx_out(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint32_t val);
35425 export function TxAddInput_set_prevtx_out(this_ptr: bigint, val: number): void {
35426 if(!isWasmInitialized) {
35427 throw new Error("initializeWasm() must be awaited first!");
35429 const nativeResponseValue = wasm.TS_TxAddInput_set_prevtx_out(this_ptr, val);
35430 // debug statements here
35432 // uint32_t TxAddInput_get_sequence(const struct LDKTxAddInput *NONNULL_PTR this_ptr);
35434 export function TxAddInput_get_sequence(this_ptr: bigint): number {
35435 if(!isWasmInitialized) {
35436 throw new Error("initializeWasm() must be awaited first!");
35438 const nativeResponseValue = wasm.TS_TxAddInput_get_sequence(this_ptr);
35439 return nativeResponseValue;
35441 // void TxAddInput_set_sequence(struct LDKTxAddInput *NONNULL_PTR this_ptr, uint32_t val);
35443 export function TxAddInput_set_sequence(this_ptr: bigint, val: number): void {
35444 if(!isWasmInitialized) {
35445 throw new Error("initializeWasm() must be awaited first!");
35447 const nativeResponseValue = wasm.TS_TxAddInput_set_sequence(this_ptr, val);
35448 // debug statements here
35450 // 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);
35452 export function TxAddInput_new(channel_id_arg: number, serial_id_arg: bigint, prevtx_arg: bigint, prevtx_out_arg: number, sequence_arg: number): bigint {
35453 if(!isWasmInitialized) {
35454 throw new Error("initializeWasm() must be awaited first!");
35456 const nativeResponseValue = wasm.TS_TxAddInput_new(channel_id_arg, serial_id_arg, prevtx_arg, prevtx_out_arg, sequence_arg);
35457 return nativeResponseValue;
35459 // uint64_t TxAddInput_clone_ptr(LDKTxAddInput *NONNULL_PTR arg);
35461 export function TxAddInput_clone_ptr(arg: bigint): bigint {
35462 if(!isWasmInitialized) {
35463 throw new Error("initializeWasm() must be awaited first!");
35465 const nativeResponseValue = wasm.TS_TxAddInput_clone_ptr(arg);
35466 return nativeResponseValue;
35468 // struct LDKTxAddInput TxAddInput_clone(const struct LDKTxAddInput *NONNULL_PTR orig);
35470 export function TxAddInput_clone(orig: bigint): bigint {
35471 if(!isWasmInitialized) {
35472 throw new Error("initializeWasm() must be awaited first!");
35474 const nativeResponseValue = wasm.TS_TxAddInput_clone(orig);
35475 return nativeResponseValue;
35477 // uint64_t TxAddInput_hash(const struct LDKTxAddInput *NONNULL_PTR o);
35479 export function TxAddInput_hash(o: bigint): bigint {
35480 if(!isWasmInitialized) {
35481 throw new Error("initializeWasm() must be awaited first!");
35483 const nativeResponseValue = wasm.TS_TxAddInput_hash(o);
35484 return nativeResponseValue;
35486 // bool TxAddInput_eq(const struct LDKTxAddInput *NONNULL_PTR a, const struct LDKTxAddInput *NONNULL_PTR b);
35488 export function TxAddInput_eq(a: bigint, b: bigint): boolean {
35489 if(!isWasmInitialized) {
35490 throw new Error("initializeWasm() must be awaited first!");
35492 const nativeResponseValue = wasm.TS_TxAddInput_eq(a, b);
35493 return nativeResponseValue;
35495 // void TxAddOutput_free(struct LDKTxAddOutput this_obj);
35497 export function TxAddOutput_free(this_obj: bigint): void {
35498 if(!isWasmInitialized) {
35499 throw new Error("initializeWasm() must be awaited first!");
35501 const nativeResponseValue = wasm.TS_TxAddOutput_free(this_obj);
35502 // debug statements here
35504 // const uint8_t (*TxAddOutput_get_channel_id(const struct LDKTxAddOutput *NONNULL_PTR this_ptr))[32];
35506 export function TxAddOutput_get_channel_id(this_ptr: bigint): number {
35507 if(!isWasmInitialized) {
35508 throw new Error("initializeWasm() must be awaited first!");
35510 const nativeResponseValue = wasm.TS_TxAddOutput_get_channel_id(this_ptr);
35511 return nativeResponseValue;
35513 // void TxAddOutput_set_channel_id(struct LDKTxAddOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35515 export function TxAddOutput_set_channel_id(this_ptr: bigint, val: number): void {
35516 if(!isWasmInitialized) {
35517 throw new Error("initializeWasm() must be awaited first!");
35519 const nativeResponseValue = wasm.TS_TxAddOutput_set_channel_id(this_ptr, val);
35520 // debug statements here
35522 // uint64_t TxAddOutput_get_serial_id(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
35524 export function TxAddOutput_get_serial_id(this_ptr: bigint): bigint {
35525 if(!isWasmInitialized) {
35526 throw new Error("initializeWasm() must be awaited first!");
35528 const nativeResponseValue = wasm.TS_TxAddOutput_get_serial_id(this_ptr);
35529 return nativeResponseValue;
35531 // void TxAddOutput_set_serial_id(struct LDKTxAddOutput *NONNULL_PTR this_ptr, uint64_t val);
35533 export function TxAddOutput_set_serial_id(this_ptr: bigint, val: bigint): void {
35534 if(!isWasmInitialized) {
35535 throw new Error("initializeWasm() must be awaited first!");
35537 const nativeResponseValue = wasm.TS_TxAddOutput_set_serial_id(this_ptr, val);
35538 // debug statements here
35540 // uint64_t TxAddOutput_get_sats(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
35542 export function TxAddOutput_get_sats(this_ptr: bigint): bigint {
35543 if(!isWasmInitialized) {
35544 throw new Error("initializeWasm() must be awaited first!");
35546 const nativeResponseValue = wasm.TS_TxAddOutput_get_sats(this_ptr);
35547 return nativeResponseValue;
35549 // void TxAddOutput_set_sats(struct LDKTxAddOutput *NONNULL_PTR this_ptr, uint64_t val);
35551 export function TxAddOutput_set_sats(this_ptr: bigint, val: bigint): void {
35552 if(!isWasmInitialized) {
35553 throw new Error("initializeWasm() must be awaited first!");
35555 const nativeResponseValue = wasm.TS_TxAddOutput_set_sats(this_ptr, val);
35556 // debug statements here
35558 // struct LDKCVec_u8Z TxAddOutput_get_script(const struct LDKTxAddOutput *NONNULL_PTR this_ptr);
35560 export function TxAddOutput_get_script(this_ptr: bigint): number {
35561 if(!isWasmInitialized) {
35562 throw new Error("initializeWasm() must be awaited first!");
35564 const nativeResponseValue = wasm.TS_TxAddOutput_get_script(this_ptr);
35565 return nativeResponseValue;
35567 // void TxAddOutput_set_script(struct LDKTxAddOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
35569 export function TxAddOutput_set_script(this_ptr: bigint, val: number): void {
35570 if(!isWasmInitialized) {
35571 throw new Error("initializeWasm() must be awaited first!");
35573 const nativeResponseValue = wasm.TS_TxAddOutput_set_script(this_ptr, val);
35574 // debug statements here
35576 // 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);
35578 export function TxAddOutput_new(channel_id_arg: number, serial_id_arg: bigint, sats_arg: bigint, script_arg: number): bigint {
35579 if(!isWasmInitialized) {
35580 throw new Error("initializeWasm() must be awaited first!");
35582 const nativeResponseValue = wasm.TS_TxAddOutput_new(channel_id_arg, serial_id_arg, sats_arg, script_arg);
35583 return nativeResponseValue;
35585 // uint64_t TxAddOutput_clone_ptr(LDKTxAddOutput *NONNULL_PTR arg);
35587 export function TxAddOutput_clone_ptr(arg: bigint): bigint {
35588 if(!isWasmInitialized) {
35589 throw new Error("initializeWasm() must be awaited first!");
35591 const nativeResponseValue = wasm.TS_TxAddOutput_clone_ptr(arg);
35592 return nativeResponseValue;
35594 // struct LDKTxAddOutput TxAddOutput_clone(const struct LDKTxAddOutput *NONNULL_PTR orig);
35596 export function TxAddOutput_clone(orig: bigint): bigint {
35597 if(!isWasmInitialized) {
35598 throw new Error("initializeWasm() must be awaited first!");
35600 const nativeResponseValue = wasm.TS_TxAddOutput_clone(orig);
35601 return nativeResponseValue;
35603 // uint64_t TxAddOutput_hash(const struct LDKTxAddOutput *NONNULL_PTR o);
35605 export function TxAddOutput_hash(o: bigint): bigint {
35606 if(!isWasmInitialized) {
35607 throw new Error("initializeWasm() must be awaited first!");
35609 const nativeResponseValue = wasm.TS_TxAddOutput_hash(o);
35610 return nativeResponseValue;
35612 // bool TxAddOutput_eq(const struct LDKTxAddOutput *NONNULL_PTR a, const struct LDKTxAddOutput *NONNULL_PTR b);
35614 export function TxAddOutput_eq(a: bigint, b: bigint): boolean {
35615 if(!isWasmInitialized) {
35616 throw new Error("initializeWasm() must be awaited first!");
35618 const nativeResponseValue = wasm.TS_TxAddOutput_eq(a, b);
35619 return nativeResponseValue;
35621 // void TxRemoveInput_free(struct LDKTxRemoveInput this_obj);
35623 export function TxRemoveInput_free(this_obj: bigint): void {
35624 if(!isWasmInitialized) {
35625 throw new Error("initializeWasm() must be awaited first!");
35627 const nativeResponseValue = wasm.TS_TxRemoveInput_free(this_obj);
35628 // debug statements here
35630 // const uint8_t (*TxRemoveInput_get_channel_id(const struct LDKTxRemoveInput *NONNULL_PTR this_ptr))[32];
35632 export function TxRemoveInput_get_channel_id(this_ptr: bigint): number {
35633 if(!isWasmInitialized) {
35634 throw new Error("initializeWasm() must be awaited first!");
35636 const nativeResponseValue = wasm.TS_TxRemoveInput_get_channel_id(this_ptr);
35637 return nativeResponseValue;
35639 // void TxRemoveInput_set_channel_id(struct LDKTxRemoveInput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35641 export function TxRemoveInput_set_channel_id(this_ptr: bigint, val: number): void {
35642 if(!isWasmInitialized) {
35643 throw new Error("initializeWasm() must be awaited first!");
35645 const nativeResponseValue = wasm.TS_TxRemoveInput_set_channel_id(this_ptr, val);
35646 // debug statements here
35648 // uint64_t TxRemoveInput_get_serial_id(const struct LDKTxRemoveInput *NONNULL_PTR this_ptr);
35650 export function TxRemoveInput_get_serial_id(this_ptr: bigint): bigint {
35651 if(!isWasmInitialized) {
35652 throw new Error("initializeWasm() must be awaited first!");
35654 const nativeResponseValue = wasm.TS_TxRemoveInput_get_serial_id(this_ptr);
35655 return nativeResponseValue;
35657 // void TxRemoveInput_set_serial_id(struct LDKTxRemoveInput *NONNULL_PTR this_ptr, uint64_t val);
35659 export function TxRemoveInput_set_serial_id(this_ptr: bigint, val: bigint): void {
35660 if(!isWasmInitialized) {
35661 throw new Error("initializeWasm() must be awaited first!");
35663 const nativeResponseValue = wasm.TS_TxRemoveInput_set_serial_id(this_ptr, val);
35664 // debug statements here
35666 // MUST_USE_RES struct LDKTxRemoveInput TxRemoveInput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg);
35668 export function TxRemoveInput_new(channel_id_arg: number, serial_id_arg: bigint): bigint {
35669 if(!isWasmInitialized) {
35670 throw new Error("initializeWasm() must be awaited first!");
35672 const nativeResponseValue = wasm.TS_TxRemoveInput_new(channel_id_arg, serial_id_arg);
35673 return nativeResponseValue;
35675 // uint64_t TxRemoveInput_clone_ptr(LDKTxRemoveInput *NONNULL_PTR arg);
35677 export function TxRemoveInput_clone_ptr(arg: bigint): bigint {
35678 if(!isWasmInitialized) {
35679 throw new Error("initializeWasm() must be awaited first!");
35681 const nativeResponseValue = wasm.TS_TxRemoveInput_clone_ptr(arg);
35682 return nativeResponseValue;
35684 // struct LDKTxRemoveInput TxRemoveInput_clone(const struct LDKTxRemoveInput *NONNULL_PTR orig);
35686 export function TxRemoveInput_clone(orig: bigint): bigint {
35687 if(!isWasmInitialized) {
35688 throw new Error("initializeWasm() must be awaited first!");
35690 const nativeResponseValue = wasm.TS_TxRemoveInput_clone(orig);
35691 return nativeResponseValue;
35693 // uint64_t TxRemoveInput_hash(const struct LDKTxRemoveInput *NONNULL_PTR o);
35695 export function TxRemoveInput_hash(o: bigint): bigint {
35696 if(!isWasmInitialized) {
35697 throw new Error("initializeWasm() must be awaited first!");
35699 const nativeResponseValue = wasm.TS_TxRemoveInput_hash(o);
35700 return nativeResponseValue;
35702 // bool TxRemoveInput_eq(const struct LDKTxRemoveInput *NONNULL_PTR a, const struct LDKTxRemoveInput *NONNULL_PTR b);
35704 export function TxRemoveInput_eq(a: bigint, b: bigint): boolean {
35705 if(!isWasmInitialized) {
35706 throw new Error("initializeWasm() must be awaited first!");
35708 const nativeResponseValue = wasm.TS_TxRemoveInput_eq(a, b);
35709 return nativeResponseValue;
35711 // void TxRemoveOutput_free(struct LDKTxRemoveOutput this_obj);
35713 export function TxRemoveOutput_free(this_obj: bigint): void {
35714 if(!isWasmInitialized) {
35715 throw new Error("initializeWasm() must be awaited first!");
35717 const nativeResponseValue = wasm.TS_TxRemoveOutput_free(this_obj);
35718 // debug statements here
35720 // const uint8_t (*TxRemoveOutput_get_channel_id(const struct LDKTxRemoveOutput *NONNULL_PTR this_ptr))[32];
35722 export function TxRemoveOutput_get_channel_id(this_ptr: bigint): number {
35723 if(!isWasmInitialized) {
35724 throw new Error("initializeWasm() must be awaited first!");
35726 const nativeResponseValue = wasm.TS_TxRemoveOutput_get_channel_id(this_ptr);
35727 return nativeResponseValue;
35729 // void TxRemoveOutput_set_channel_id(struct LDKTxRemoveOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35731 export function TxRemoveOutput_set_channel_id(this_ptr: bigint, val: number): void {
35732 if(!isWasmInitialized) {
35733 throw new Error("initializeWasm() must be awaited first!");
35735 const nativeResponseValue = wasm.TS_TxRemoveOutput_set_channel_id(this_ptr, val);
35736 // debug statements here
35738 // uint64_t TxRemoveOutput_get_serial_id(const struct LDKTxRemoveOutput *NONNULL_PTR this_ptr);
35740 export function TxRemoveOutput_get_serial_id(this_ptr: bigint): bigint {
35741 if(!isWasmInitialized) {
35742 throw new Error("initializeWasm() must be awaited first!");
35744 const nativeResponseValue = wasm.TS_TxRemoveOutput_get_serial_id(this_ptr);
35745 return nativeResponseValue;
35747 // void TxRemoveOutput_set_serial_id(struct LDKTxRemoveOutput *NONNULL_PTR this_ptr, uint64_t val);
35749 export function TxRemoveOutput_set_serial_id(this_ptr: bigint, val: bigint): void {
35750 if(!isWasmInitialized) {
35751 throw new Error("initializeWasm() must be awaited first!");
35753 const nativeResponseValue = wasm.TS_TxRemoveOutput_set_serial_id(this_ptr, val);
35754 // debug statements here
35756 // MUST_USE_RES struct LDKTxRemoveOutput TxRemoveOutput_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t serial_id_arg);
35758 export function TxRemoveOutput_new(channel_id_arg: number, serial_id_arg: bigint): bigint {
35759 if(!isWasmInitialized) {
35760 throw new Error("initializeWasm() must be awaited first!");
35762 const nativeResponseValue = wasm.TS_TxRemoveOutput_new(channel_id_arg, serial_id_arg);
35763 return nativeResponseValue;
35765 // uint64_t TxRemoveOutput_clone_ptr(LDKTxRemoveOutput *NONNULL_PTR arg);
35767 export function TxRemoveOutput_clone_ptr(arg: bigint): bigint {
35768 if(!isWasmInitialized) {
35769 throw new Error("initializeWasm() must be awaited first!");
35771 const nativeResponseValue = wasm.TS_TxRemoveOutput_clone_ptr(arg);
35772 return nativeResponseValue;
35774 // struct LDKTxRemoveOutput TxRemoveOutput_clone(const struct LDKTxRemoveOutput *NONNULL_PTR orig);
35776 export function TxRemoveOutput_clone(orig: bigint): bigint {
35777 if(!isWasmInitialized) {
35778 throw new Error("initializeWasm() must be awaited first!");
35780 const nativeResponseValue = wasm.TS_TxRemoveOutput_clone(orig);
35781 return nativeResponseValue;
35783 // uint64_t TxRemoveOutput_hash(const struct LDKTxRemoveOutput *NONNULL_PTR o);
35785 export function TxRemoveOutput_hash(o: bigint): bigint {
35786 if(!isWasmInitialized) {
35787 throw new Error("initializeWasm() must be awaited first!");
35789 const nativeResponseValue = wasm.TS_TxRemoveOutput_hash(o);
35790 return nativeResponseValue;
35792 // bool TxRemoveOutput_eq(const struct LDKTxRemoveOutput *NONNULL_PTR a, const struct LDKTxRemoveOutput *NONNULL_PTR b);
35794 export function TxRemoveOutput_eq(a: bigint, b: bigint): boolean {
35795 if(!isWasmInitialized) {
35796 throw new Error("initializeWasm() must be awaited first!");
35798 const nativeResponseValue = wasm.TS_TxRemoveOutput_eq(a, b);
35799 return nativeResponseValue;
35801 // void TxComplete_free(struct LDKTxComplete this_obj);
35803 export function TxComplete_free(this_obj: bigint): void {
35804 if(!isWasmInitialized) {
35805 throw new Error("initializeWasm() must be awaited first!");
35807 const nativeResponseValue = wasm.TS_TxComplete_free(this_obj);
35808 // debug statements here
35810 // const uint8_t (*TxComplete_get_channel_id(const struct LDKTxComplete *NONNULL_PTR this_ptr))[32];
35812 export function TxComplete_get_channel_id(this_ptr: bigint): number {
35813 if(!isWasmInitialized) {
35814 throw new Error("initializeWasm() must be awaited first!");
35816 const nativeResponseValue = wasm.TS_TxComplete_get_channel_id(this_ptr);
35817 return nativeResponseValue;
35819 // void TxComplete_set_channel_id(struct LDKTxComplete *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35821 export function TxComplete_set_channel_id(this_ptr: bigint, val: number): void {
35822 if(!isWasmInitialized) {
35823 throw new Error("initializeWasm() must be awaited first!");
35825 const nativeResponseValue = wasm.TS_TxComplete_set_channel_id(this_ptr, val);
35826 // debug statements here
35828 // MUST_USE_RES struct LDKTxComplete TxComplete_new(struct LDKThirtyTwoBytes channel_id_arg);
35830 export function TxComplete_new(channel_id_arg: number): bigint {
35831 if(!isWasmInitialized) {
35832 throw new Error("initializeWasm() must be awaited first!");
35834 const nativeResponseValue = wasm.TS_TxComplete_new(channel_id_arg);
35835 return nativeResponseValue;
35837 // uint64_t TxComplete_clone_ptr(LDKTxComplete *NONNULL_PTR arg);
35839 export function TxComplete_clone_ptr(arg: bigint): bigint {
35840 if(!isWasmInitialized) {
35841 throw new Error("initializeWasm() must be awaited first!");
35843 const nativeResponseValue = wasm.TS_TxComplete_clone_ptr(arg);
35844 return nativeResponseValue;
35846 // struct LDKTxComplete TxComplete_clone(const struct LDKTxComplete *NONNULL_PTR orig);
35848 export function TxComplete_clone(orig: bigint): bigint {
35849 if(!isWasmInitialized) {
35850 throw new Error("initializeWasm() must be awaited first!");
35852 const nativeResponseValue = wasm.TS_TxComplete_clone(orig);
35853 return nativeResponseValue;
35855 // uint64_t TxComplete_hash(const struct LDKTxComplete *NONNULL_PTR o);
35857 export function TxComplete_hash(o: bigint): bigint {
35858 if(!isWasmInitialized) {
35859 throw new Error("initializeWasm() must be awaited first!");
35861 const nativeResponseValue = wasm.TS_TxComplete_hash(o);
35862 return nativeResponseValue;
35864 // bool TxComplete_eq(const struct LDKTxComplete *NONNULL_PTR a, const struct LDKTxComplete *NONNULL_PTR b);
35866 export function TxComplete_eq(a: bigint, b: bigint): boolean {
35867 if(!isWasmInitialized) {
35868 throw new Error("initializeWasm() must be awaited first!");
35870 const nativeResponseValue = wasm.TS_TxComplete_eq(a, b);
35871 return nativeResponseValue;
35873 // void TxSignatures_free(struct LDKTxSignatures this_obj);
35875 export function TxSignatures_free(this_obj: bigint): void {
35876 if(!isWasmInitialized) {
35877 throw new Error("initializeWasm() must be awaited first!");
35879 const nativeResponseValue = wasm.TS_TxSignatures_free(this_obj);
35880 // debug statements here
35882 // const uint8_t (*TxSignatures_get_channel_id(const struct LDKTxSignatures *NONNULL_PTR this_ptr))[32];
35884 export function TxSignatures_get_channel_id(this_ptr: bigint): number {
35885 if(!isWasmInitialized) {
35886 throw new Error("initializeWasm() must be awaited first!");
35888 const nativeResponseValue = wasm.TS_TxSignatures_get_channel_id(this_ptr);
35889 return nativeResponseValue;
35891 // void TxSignatures_set_channel_id(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35893 export function TxSignatures_set_channel_id(this_ptr: bigint, val: number): void {
35894 if(!isWasmInitialized) {
35895 throw new Error("initializeWasm() must be awaited first!");
35897 const nativeResponseValue = wasm.TS_TxSignatures_set_channel_id(this_ptr, val);
35898 // debug statements here
35900 // const uint8_t (*TxSignatures_get_tx_hash(const struct LDKTxSignatures *NONNULL_PTR this_ptr))[32];
35902 export function TxSignatures_get_tx_hash(this_ptr: bigint): number {
35903 if(!isWasmInitialized) {
35904 throw new Error("initializeWasm() must be awaited first!");
35906 const nativeResponseValue = wasm.TS_TxSignatures_get_tx_hash(this_ptr);
35907 return nativeResponseValue;
35909 // void TxSignatures_set_tx_hash(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
35911 export function TxSignatures_set_tx_hash(this_ptr: bigint, val: number): void {
35912 if(!isWasmInitialized) {
35913 throw new Error("initializeWasm() must be awaited first!");
35915 const nativeResponseValue = wasm.TS_TxSignatures_set_tx_hash(this_ptr, val);
35916 // debug statements here
35918 // struct LDKCVec_WitnessZ TxSignatures_get_witnesses(const struct LDKTxSignatures *NONNULL_PTR this_ptr);
35920 export function TxSignatures_get_witnesses(this_ptr: bigint): number {
35921 if(!isWasmInitialized) {
35922 throw new Error("initializeWasm() must be awaited first!");
35924 const nativeResponseValue = wasm.TS_TxSignatures_get_witnesses(this_ptr);
35925 return nativeResponseValue;
35927 // void TxSignatures_set_witnesses(struct LDKTxSignatures *NONNULL_PTR this_ptr, struct LDKCVec_WitnessZ val);
35929 export function TxSignatures_set_witnesses(this_ptr: bigint, val: number): void {
35930 if(!isWasmInitialized) {
35931 throw new Error("initializeWasm() must be awaited first!");
35933 const nativeResponseValue = wasm.TS_TxSignatures_set_witnesses(this_ptr, val);
35934 // debug statements here
35936 // MUST_USE_RES struct LDKTxSignatures TxSignatures_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKThirtyTwoBytes tx_hash_arg, struct LDKCVec_WitnessZ witnesses_arg);
35938 export function TxSignatures_new(channel_id_arg: number, tx_hash_arg: number, witnesses_arg: number): bigint {
35939 if(!isWasmInitialized) {
35940 throw new Error("initializeWasm() must be awaited first!");
35942 const nativeResponseValue = wasm.TS_TxSignatures_new(channel_id_arg, tx_hash_arg, witnesses_arg);
35943 return nativeResponseValue;
35945 // uint64_t TxSignatures_clone_ptr(LDKTxSignatures *NONNULL_PTR arg);
35947 export function TxSignatures_clone_ptr(arg: bigint): bigint {
35948 if(!isWasmInitialized) {
35949 throw new Error("initializeWasm() must be awaited first!");
35951 const nativeResponseValue = wasm.TS_TxSignatures_clone_ptr(arg);
35952 return nativeResponseValue;
35954 // struct LDKTxSignatures TxSignatures_clone(const struct LDKTxSignatures *NONNULL_PTR orig);
35956 export function TxSignatures_clone(orig: bigint): bigint {
35957 if(!isWasmInitialized) {
35958 throw new Error("initializeWasm() must be awaited first!");
35960 const nativeResponseValue = wasm.TS_TxSignatures_clone(orig);
35961 return nativeResponseValue;
35963 // uint64_t TxSignatures_hash(const struct LDKTxSignatures *NONNULL_PTR o);
35965 export function TxSignatures_hash(o: bigint): bigint {
35966 if(!isWasmInitialized) {
35967 throw new Error("initializeWasm() must be awaited first!");
35969 const nativeResponseValue = wasm.TS_TxSignatures_hash(o);
35970 return nativeResponseValue;
35972 // bool TxSignatures_eq(const struct LDKTxSignatures *NONNULL_PTR a, const struct LDKTxSignatures *NONNULL_PTR b);
35974 export function TxSignatures_eq(a: bigint, b: bigint): boolean {
35975 if(!isWasmInitialized) {
35976 throw new Error("initializeWasm() must be awaited first!");
35978 const nativeResponseValue = wasm.TS_TxSignatures_eq(a, b);
35979 return nativeResponseValue;
35981 // void TxInitRbf_free(struct LDKTxInitRbf this_obj);
35983 export function TxInitRbf_free(this_obj: bigint): void {
35984 if(!isWasmInitialized) {
35985 throw new Error("initializeWasm() must be awaited first!");
35987 const nativeResponseValue = wasm.TS_TxInitRbf_free(this_obj);
35988 // debug statements here
35990 // const uint8_t (*TxInitRbf_get_channel_id(const struct LDKTxInitRbf *NONNULL_PTR this_ptr))[32];
35992 export function TxInitRbf_get_channel_id(this_ptr: bigint): number {
35993 if(!isWasmInitialized) {
35994 throw new Error("initializeWasm() must be awaited first!");
35996 const nativeResponseValue = wasm.TS_TxInitRbf_get_channel_id(this_ptr);
35997 return nativeResponseValue;
35999 // void TxInitRbf_set_channel_id(struct LDKTxInitRbf *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
36001 export function TxInitRbf_set_channel_id(this_ptr: bigint, val: number): void {
36002 if(!isWasmInitialized) {
36003 throw new Error("initializeWasm() must be awaited first!");
36005 const nativeResponseValue = wasm.TS_TxInitRbf_set_channel_id(this_ptr, val);
36006 // debug statements here
36008 // uint32_t TxInitRbf_get_locktime(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
36010 export function TxInitRbf_get_locktime(this_ptr: bigint): number {
36011 if(!isWasmInitialized) {
36012 throw new Error("initializeWasm() must be awaited first!");
36014 const nativeResponseValue = wasm.TS_TxInitRbf_get_locktime(this_ptr);
36015 return nativeResponseValue;
36017 // void TxInitRbf_set_locktime(struct LDKTxInitRbf *NONNULL_PTR this_ptr, uint32_t val);
36019 export function TxInitRbf_set_locktime(this_ptr: bigint, val: number): void {
36020 if(!isWasmInitialized) {
36021 throw new Error("initializeWasm() must be awaited first!");
36023 const nativeResponseValue = wasm.TS_TxInitRbf_set_locktime(this_ptr, val);
36024 // debug statements here
36026 // uint32_t TxInitRbf_get_feerate_sat_per_1000_weight(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
36028 export function TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr: bigint): number {
36029 if(!isWasmInitialized) {
36030 throw new Error("initializeWasm() must be awaited first!");
36032 const nativeResponseValue = wasm.TS_TxInitRbf_get_feerate_sat_per_1000_weight(this_ptr);
36033 return nativeResponseValue;
36035 // void TxInitRbf_set_feerate_sat_per_1000_weight(struct LDKTxInitRbf *NONNULL_PTR this_ptr, uint32_t val);
36037 export function TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: number): void {
36038 if(!isWasmInitialized) {
36039 throw new Error("initializeWasm() must be awaited first!");
36041 const nativeResponseValue = wasm.TS_TxInitRbf_set_feerate_sat_per_1000_weight(this_ptr, val);
36042 // debug statements here
36044 // struct LDKCOption_i64Z TxInitRbf_get_funding_output_contribution(const struct LDKTxInitRbf *NONNULL_PTR this_ptr);
36046 export function TxInitRbf_get_funding_output_contribution(this_ptr: bigint): bigint {
36047 if(!isWasmInitialized) {
36048 throw new Error("initializeWasm() must be awaited first!");
36050 const nativeResponseValue = wasm.TS_TxInitRbf_get_funding_output_contribution(this_ptr);
36051 return nativeResponseValue;
36053 // void TxInitRbf_set_funding_output_contribution(struct LDKTxInitRbf *NONNULL_PTR this_ptr, struct LDKCOption_i64Z val);
36055 export function TxInitRbf_set_funding_output_contribution(this_ptr: bigint, val: bigint): void {
36056 if(!isWasmInitialized) {
36057 throw new Error("initializeWasm() must be awaited first!");
36059 const nativeResponseValue = wasm.TS_TxInitRbf_set_funding_output_contribution(this_ptr, val);
36060 // debug statements here
36062 // 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);
36064 export function TxInitRbf_new(channel_id_arg: number, locktime_arg: number, feerate_sat_per_1000_weight_arg: number, funding_output_contribution_arg: bigint): bigint {
36065 if(!isWasmInitialized) {
36066 throw new Error("initializeWasm() must be awaited first!");
36068 const nativeResponseValue = wasm.TS_TxInitRbf_new(channel_id_arg, locktime_arg, feerate_sat_per_1000_weight_arg, funding_output_contribution_arg);
36069 return nativeResponseValue;
36071 // uint64_t TxInitRbf_clone_ptr(LDKTxInitRbf *NONNULL_PTR arg);
36073 export function TxInitRbf_clone_ptr(arg: bigint): bigint {
36074 if(!isWasmInitialized) {
36075 throw new Error("initializeWasm() must be awaited first!");
36077 const nativeResponseValue = wasm.TS_TxInitRbf_clone_ptr(arg);
36078 return nativeResponseValue;
36080 // struct LDKTxInitRbf TxInitRbf_clone(const struct LDKTxInitRbf *NONNULL_PTR orig);
36082 export function TxInitRbf_clone(orig: bigint): bigint {
36083 if(!isWasmInitialized) {
36084 throw new Error("initializeWasm() must be awaited first!");
36086 const nativeResponseValue = wasm.TS_TxInitRbf_clone(orig);
36087 return nativeResponseValue;
36089 // uint64_t TxInitRbf_hash(const struct LDKTxInitRbf *NONNULL_PTR o);
36091 export function TxInitRbf_hash(o: bigint): bigint {
36092 if(!isWasmInitialized) {
36093 throw new Error("initializeWasm() must be awaited first!");
36095 const nativeResponseValue = wasm.TS_TxInitRbf_hash(o);
36096 return nativeResponseValue;
36098 // bool TxInitRbf_eq(const struct LDKTxInitRbf *NONNULL_PTR a, const struct LDKTxInitRbf *NONNULL_PTR b);
36100 export function TxInitRbf_eq(a: bigint, b: bigint): boolean {
36101 if(!isWasmInitialized) {
36102 throw new Error("initializeWasm() must be awaited first!");
36104 const nativeResponseValue = wasm.TS_TxInitRbf_eq(a, b);
36105 return nativeResponseValue;
36107 // void TxAckRbf_free(struct LDKTxAckRbf this_obj);
36109 export function TxAckRbf_free(this_obj: bigint): void {
36110 if(!isWasmInitialized) {
36111 throw new Error("initializeWasm() must be awaited first!");
36113 const nativeResponseValue = wasm.TS_TxAckRbf_free(this_obj);
36114 // debug statements here
36116 // const uint8_t (*TxAckRbf_get_channel_id(const struct LDKTxAckRbf *NONNULL_PTR this_ptr))[32];
36118 export function TxAckRbf_get_channel_id(this_ptr: bigint): number {
36119 if(!isWasmInitialized) {
36120 throw new Error("initializeWasm() must be awaited first!");
36122 const nativeResponseValue = wasm.TS_TxAckRbf_get_channel_id(this_ptr);
36123 return nativeResponseValue;
36125 // void TxAckRbf_set_channel_id(struct LDKTxAckRbf *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
36127 export function TxAckRbf_set_channel_id(this_ptr: bigint, val: number): void {
36128 if(!isWasmInitialized) {
36129 throw new Error("initializeWasm() must be awaited first!");
36131 const nativeResponseValue = wasm.TS_TxAckRbf_set_channel_id(this_ptr, val);
36132 // debug statements here
36134 // struct LDKCOption_i64Z TxAckRbf_get_funding_output_contribution(const struct LDKTxAckRbf *NONNULL_PTR this_ptr);
36136 export function TxAckRbf_get_funding_output_contribution(this_ptr: bigint): bigint {
36137 if(!isWasmInitialized) {
36138 throw new Error("initializeWasm() must be awaited first!");
36140 const nativeResponseValue = wasm.TS_TxAckRbf_get_funding_output_contribution(this_ptr);
36141 return nativeResponseValue;
36143 // void TxAckRbf_set_funding_output_contribution(struct LDKTxAckRbf *NONNULL_PTR this_ptr, struct LDKCOption_i64Z val);
36145 export function TxAckRbf_set_funding_output_contribution(this_ptr: bigint, val: bigint): void {
36146 if(!isWasmInitialized) {
36147 throw new Error("initializeWasm() must be awaited first!");
36149 const nativeResponseValue = wasm.TS_TxAckRbf_set_funding_output_contribution(this_ptr, val);
36150 // debug statements here
36152 // MUST_USE_RES struct LDKTxAckRbf TxAckRbf_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCOption_i64Z funding_output_contribution_arg);
36154 export function TxAckRbf_new(channel_id_arg: number, funding_output_contribution_arg: bigint): bigint {
36155 if(!isWasmInitialized) {
36156 throw new Error("initializeWasm() must be awaited first!");
36158 const nativeResponseValue = wasm.TS_TxAckRbf_new(channel_id_arg, funding_output_contribution_arg);
36159 return nativeResponseValue;
36161 // uint64_t TxAckRbf_clone_ptr(LDKTxAckRbf *NONNULL_PTR arg);
36163 export function TxAckRbf_clone_ptr(arg: bigint): bigint {
36164 if(!isWasmInitialized) {
36165 throw new Error("initializeWasm() must be awaited first!");
36167 const nativeResponseValue = wasm.TS_TxAckRbf_clone_ptr(arg);
36168 return nativeResponseValue;
36170 // struct LDKTxAckRbf TxAckRbf_clone(const struct LDKTxAckRbf *NONNULL_PTR orig);
36172 export function TxAckRbf_clone(orig: bigint): bigint {
36173 if(!isWasmInitialized) {
36174 throw new Error("initializeWasm() must be awaited first!");
36176 const nativeResponseValue = wasm.TS_TxAckRbf_clone(orig);
36177 return nativeResponseValue;
36179 // uint64_t TxAckRbf_hash(const struct LDKTxAckRbf *NONNULL_PTR o);
36181 export function TxAckRbf_hash(o: bigint): bigint {
36182 if(!isWasmInitialized) {
36183 throw new Error("initializeWasm() must be awaited first!");
36185 const nativeResponseValue = wasm.TS_TxAckRbf_hash(o);
36186 return nativeResponseValue;
36188 // bool TxAckRbf_eq(const struct LDKTxAckRbf *NONNULL_PTR a, const struct LDKTxAckRbf *NONNULL_PTR b);
36190 export function TxAckRbf_eq(a: bigint, b: bigint): boolean {
36191 if(!isWasmInitialized) {
36192 throw new Error("initializeWasm() must be awaited first!");
36194 const nativeResponseValue = wasm.TS_TxAckRbf_eq(a, b);
36195 return nativeResponseValue;
36197 // void TxAbort_free(struct LDKTxAbort this_obj);
36199 export function TxAbort_free(this_obj: bigint): void {
36200 if(!isWasmInitialized) {
36201 throw new Error("initializeWasm() must be awaited first!");
36203 const nativeResponseValue = wasm.TS_TxAbort_free(this_obj);
36204 // debug statements here
36206 // const uint8_t (*TxAbort_get_channel_id(const struct LDKTxAbort *NONNULL_PTR this_ptr))[32];
36208 export function TxAbort_get_channel_id(this_ptr: bigint): number {
36209 if(!isWasmInitialized) {
36210 throw new Error("initializeWasm() must be awaited first!");
36212 const nativeResponseValue = wasm.TS_TxAbort_get_channel_id(this_ptr);
36213 return nativeResponseValue;
36215 // void TxAbort_set_channel_id(struct LDKTxAbort *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
36217 export function TxAbort_set_channel_id(this_ptr: bigint, val: number): void {
36218 if(!isWasmInitialized) {
36219 throw new Error("initializeWasm() must be awaited first!");
36221 const nativeResponseValue = wasm.TS_TxAbort_set_channel_id(this_ptr, val);
36222 // debug statements here
36224 // struct LDKCVec_u8Z TxAbort_get_data(const struct LDKTxAbort *NONNULL_PTR this_ptr);
36226 export function TxAbort_get_data(this_ptr: bigint): number {
36227 if(!isWasmInitialized) {
36228 throw new Error("initializeWasm() must be awaited first!");
36230 const nativeResponseValue = wasm.TS_TxAbort_get_data(this_ptr);
36231 return nativeResponseValue;
36233 // void TxAbort_set_data(struct LDKTxAbort *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
36235 export function TxAbort_set_data(this_ptr: bigint, val: number): void {
36236 if(!isWasmInitialized) {
36237 throw new Error("initializeWasm() must be awaited first!");
36239 const nativeResponseValue = wasm.TS_TxAbort_set_data(this_ptr, val);
36240 // debug statements here
36242 // MUST_USE_RES struct LDKTxAbort TxAbort_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z data_arg);
36244 export function TxAbort_new(channel_id_arg: number, data_arg: number): bigint {
36245 if(!isWasmInitialized) {
36246 throw new Error("initializeWasm() must be awaited first!");
36248 const nativeResponseValue = wasm.TS_TxAbort_new(channel_id_arg, data_arg);
36249 return nativeResponseValue;
36251 // uint64_t TxAbort_clone_ptr(LDKTxAbort *NONNULL_PTR arg);
36253 export function TxAbort_clone_ptr(arg: bigint): bigint {
36254 if(!isWasmInitialized) {
36255 throw new Error("initializeWasm() must be awaited first!");
36257 const nativeResponseValue = wasm.TS_TxAbort_clone_ptr(arg);
36258 return nativeResponseValue;
36260 // struct LDKTxAbort TxAbort_clone(const struct LDKTxAbort *NONNULL_PTR orig);
36262 export function TxAbort_clone(orig: bigint): bigint {
36263 if(!isWasmInitialized) {
36264 throw new Error("initializeWasm() must be awaited first!");
36266 const nativeResponseValue = wasm.TS_TxAbort_clone(orig);
36267 return nativeResponseValue;
36269 // uint64_t TxAbort_hash(const struct LDKTxAbort *NONNULL_PTR o);
36271 export function TxAbort_hash(o: bigint): bigint {
36272 if(!isWasmInitialized) {
36273 throw new Error("initializeWasm() must be awaited first!");
36275 const nativeResponseValue = wasm.TS_TxAbort_hash(o);
36276 return nativeResponseValue;
36278 // bool TxAbort_eq(const struct LDKTxAbort *NONNULL_PTR a, const struct LDKTxAbort *NONNULL_PTR b);
36280 export function TxAbort_eq(a: bigint, b: bigint): boolean {
36281 if(!isWasmInitialized) {
36282 throw new Error("initializeWasm() must be awaited first!");
36284 const nativeResponseValue = wasm.TS_TxAbort_eq(a, b);
36285 return nativeResponseValue;
36287 // void Shutdown_free(struct LDKShutdown this_obj);
36289 export function Shutdown_free(this_obj: bigint): void {
36290 if(!isWasmInitialized) {
36291 throw new Error("initializeWasm() must be awaited first!");
36293 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
36294 // debug statements here
36296 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
36298 export function Shutdown_get_channel_id(this_ptr: bigint): number {
36299 if(!isWasmInitialized) {
36300 throw new Error("initializeWasm() must be awaited first!");
36302 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
36303 return nativeResponseValue;
36305 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
36307 export function Shutdown_set_channel_id(this_ptr: bigint, val: number): void {
36308 if(!isWasmInitialized) {
36309 throw new Error("initializeWasm() must be awaited first!");
36311 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
36312 // debug statements here
36314 // struct LDKCVec_u8Z Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
36316 export function Shutdown_get_scriptpubkey(this_ptr: bigint): number {
36317 if(!isWasmInitialized) {
36318 throw new Error("initializeWasm() must be awaited first!");
36320 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
36321 return nativeResponseValue;
36323 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
36325 export function Shutdown_set_scriptpubkey(this_ptr: bigint, val: number): void {
36326 if(!isWasmInitialized) {
36327 throw new Error("initializeWasm() must be awaited first!");
36329 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
36330 // debug statements here
36332 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
36334 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): bigint {
36335 if(!isWasmInitialized) {
36336 throw new Error("initializeWasm() must be awaited first!");
36338 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
36339 return nativeResponseValue;
36341 // uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
36343 export function Shutdown_clone_ptr(arg: bigint): bigint {
36344 if(!isWasmInitialized) {
36345 throw new Error("initializeWasm() must be awaited first!");
36347 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
36348 return nativeResponseValue;
36350 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
36352 export function Shutdown_clone(orig: bigint): bigint {
36353 if(!isWasmInitialized) {
36354 throw new Error("initializeWasm() must be awaited first!");
36356 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
36357 return nativeResponseValue;
36359 // uint64_t Shutdown_hash(const struct LDKShutdown *NONNULL_PTR o);
36361 export function Shutdown_hash(o: bigint): bigint {
36362 if(!isWasmInitialized) {
36363 throw new Error("initializeWasm() must be awaited first!");
36365 const nativeResponseValue = wasm.TS_Shutdown_hash(o);
36366 return nativeResponseValue;
36368 // bool Shutdown_eq(const struct LDKShutdown *NONNULL_PTR a, const struct LDKShutdown *NONNULL_PTR b);
36370 export function Shutdown_eq(a: bigint, b: bigint): boolean {
36371 if(!isWasmInitialized) {
36372 throw new Error("initializeWasm() must be awaited first!");
36374 const nativeResponseValue = wasm.TS_Shutdown_eq(a, b);
36375 return nativeResponseValue;
36377 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
36379 export function ClosingSignedFeeRange_free(this_obj: bigint): void {
36380 if(!isWasmInitialized) {
36381 throw new Error("initializeWasm() must be awaited first!");
36383 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
36384 // debug statements here
36386 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
36388 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: bigint): bigint {
36389 if(!isWasmInitialized) {
36390 throw new Error("initializeWasm() must be awaited first!");
36392 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
36393 return nativeResponseValue;
36395 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
36397 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: bigint, val: bigint): void {
36398 if(!isWasmInitialized) {
36399 throw new Error("initializeWasm() must be awaited first!");
36401 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
36402 // debug statements here
36404 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
36406 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: bigint): bigint {
36407 if(!isWasmInitialized) {
36408 throw new Error("initializeWasm() must be awaited first!");
36410 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
36411 return nativeResponseValue;
36413 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
36415 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: bigint, val: bigint): void {
36416 if(!isWasmInitialized) {
36417 throw new Error("initializeWasm() must be awaited first!");
36419 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
36420 // debug statements here
36422 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
36424 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): bigint {
36425 if(!isWasmInitialized) {
36426 throw new Error("initializeWasm() must be awaited first!");
36428 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
36429 return nativeResponseValue;
36431 // uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
36433 export function ClosingSignedFeeRange_clone_ptr(arg: bigint): bigint {
36434 if(!isWasmInitialized) {
36435 throw new Error("initializeWasm() must be awaited first!");
36437 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
36438 return nativeResponseValue;
36440 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
36442 export function ClosingSignedFeeRange_clone(orig: bigint): bigint {
36443 if(!isWasmInitialized) {
36444 throw new Error("initializeWasm() must be awaited first!");
36446 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
36447 return nativeResponseValue;
36449 // uint64_t ClosingSignedFeeRange_hash(const struct LDKClosingSignedFeeRange *NONNULL_PTR o);
36451 export function ClosingSignedFeeRange_hash(o: bigint): bigint {
36452 if(!isWasmInitialized) {
36453 throw new Error("initializeWasm() must be awaited first!");
36455 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_hash(o);
36456 return nativeResponseValue;
36458 // bool ClosingSignedFeeRange_eq(const struct LDKClosingSignedFeeRange *NONNULL_PTR a, const struct LDKClosingSignedFeeRange *NONNULL_PTR b);
36460 export function ClosingSignedFeeRange_eq(a: bigint, b: bigint): boolean {
36461 if(!isWasmInitialized) {
36462 throw new Error("initializeWasm() must be awaited first!");
36464 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_eq(a, b);
36465 return nativeResponseValue;
36467 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
36469 export function ClosingSigned_free(this_obj: bigint): void {
36470 if(!isWasmInitialized) {
36471 throw new Error("initializeWasm() must be awaited first!");
36473 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
36474 // debug statements here
36476 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
36478 export function ClosingSigned_get_channel_id(this_ptr: bigint): number {
36479 if(!isWasmInitialized) {
36480 throw new Error("initializeWasm() must be awaited first!");
36482 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
36483 return nativeResponseValue;
36485 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
36487 export function ClosingSigned_set_channel_id(this_ptr: bigint, val: number): void {
36488 if(!isWasmInitialized) {
36489 throw new Error("initializeWasm() must be awaited first!");
36491 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
36492 // debug statements here
36494 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
36496 export function ClosingSigned_get_fee_satoshis(this_ptr: bigint): bigint {
36497 if(!isWasmInitialized) {
36498 throw new Error("initializeWasm() must be awaited first!");
36500 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
36501 return nativeResponseValue;
36503 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
36505 export function ClosingSigned_set_fee_satoshis(this_ptr: bigint, val: bigint): void {
36506 if(!isWasmInitialized) {
36507 throw new Error("initializeWasm() must be awaited first!");
36509 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
36510 // debug statements here
36512 // struct LDKECDSASignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
36514 export function ClosingSigned_get_signature(this_ptr: bigint): number {
36515 if(!isWasmInitialized) {
36516 throw new Error("initializeWasm() must be awaited first!");
36518 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
36519 return nativeResponseValue;
36521 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
36523 export function ClosingSigned_set_signature(this_ptr: bigint, val: number): void {
36524 if(!isWasmInitialized) {
36525 throw new Error("initializeWasm() must be awaited first!");
36527 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
36528 // debug statements here
36530 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
36532 export function ClosingSigned_get_fee_range(this_ptr: bigint): bigint {
36533 if(!isWasmInitialized) {
36534 throw new Error("initializeWasm() must be awaited first!");
36536 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
36537 return nativeResponseValue;
36539 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
36541 export function ClosingSigned_set_fee_range(this_ptr: bigint, val: bigint): void {
36542 if(!isWasmInitialized) {
36543 throw new Error("initializeWasm() must be awaited first!");
36545 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
36546 // debug statements here
36548 // 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);
36550 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: bigint): bigint {
36551 if(!isWasmInitialized) {
36552 throw new Error("initializeWasm() must be awaited first!");
36554 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
36555 return nativeResponseValue;
36557 // uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
36559 export function ClosingSigned_clone_ptr(arg: bigint): bigint {
36560 if(!isWasmInitialized) {
36561 throw new Error("initializeWasm() must be awaited first!");
36563 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
36564 return nativeResponseValue;
36566 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
36568 export function ClosingSigned_clone(orig: bigint): bigint {
36569 if(!isWasmInitialized) {
36570 throw new Error("initializeWasm() must be awaited first!");
36572 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
36573 return nativeResponseValue;
36575 // uint64_t ClosingSigned_hash(const struct LDKClosingSigned *NONNULL_PTR o);
36577 export function ClosingSigned_hash(o: bigint): bigint {
36578 if(!isWasmInitialized) {
36579 throw new Error("initializeWasm() must be awaited first!");
36581 const nativeResponseValue = wasm.TS_ClosingSigned_hash(o);
36582 return nativeResponseValue;
36584 // bool ClosingSigned_eq(const struct LDKClosingSigned *NONNULL_PTR a, const struct LDKClosingSigned *NONNULL_PTR b);
36586 export function ClosingSigned_eq(a: bigint, b: bigint): boolean {
36587 if(!isWasmInitialized) {
36588 throw new Error("initializeWasm() must be awaited first!");
36590 const nativeResponseValue = wasm.TS_ClosingSigned_eq(a, b);
36591 return nativeResponseValue;
36593 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
36595 export function UpdateAddHTLC_free(this_obj: bigint): void {
36596 if(!isWasmInitialized) {
36597 throw new Error("initializeWasm() must be awaited first!");
36599 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
36600 // debug statements here
36602 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
36604 export function UpdateAddHTLC_get_channel_id(this_ptr: bigint): number {
36605 if(!isWasmInitialized) {
36606 throw new Error("initializeWasm() must be awaited first!");
36608 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
36609 return nativeResponseValue;
36611 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
36613 export function UpdateAddHTLC_set_channel_id(this_ptr: bigint, val: number): void {
36614 if(!isWasmInitialized) {
36615 throw new Error("initializeWasm() must be awaited first!");
36617 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
36618 // debug statements here
36620 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
36622 export function UpdateAddHTLC_get_htlc_id(this_ptr: bigint): bigint {
36623 if(!isWasmInitialized) {
36624 throw new Error("initializeWasm() must be awaited first!");
36626 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
36627 return nativeResponseValue;
36629 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
36631 export function UpdateAddHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
36632 if(!isWasmInitialized) {
36633 throw new Error("initializeWasm() must be awaited first!");
36635 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
36636 // debug statements here
36638 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
36640 export function UpdateAddHTLC_get_amount_msat(this_ptr: bigint): bigint {
36641 if(!isWasmInitialized) {
36642 throw new Error("initializeWasm() must be awaited first!");
36644 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
36645 return nativeResponseValue;
36647 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
36649 export function UpdateAddHTLC_set_amount_msat(this_ptr: bigint, val: bigint): void {
36650 if(!isWasmInitialized) {
36651 throw new Error("initializeWasm() must be awaited first!");
36653 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
36654 // debug statements here
36656 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
36658 export function UpdateAddHTLC_get_payment_hash(this_ptr: bigint): number {
36659 if(!isWasmInitialized) {
36660 throw new Error("initializeWasm() must be awaited first!");
36662 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
36663 return nativeResponseValue;
36665 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
36667 export function UpdateAddHTLC_set_payment_hash(this_ptr: bigint, val: number): void {
36668 if(!isWasmInitialized) {
36669 throw new Error("initializeWasm() must be awaited first!");
36671 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
36672 // debug statements here
36674 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
36676 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: bigint): number {
36677 if(!isWasmInitialized) {
36678 throw new Error("initializeWasm() must be awaited first!");
36680 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
36681 return nativeResponseValue;
36683 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
36685 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
36686 if(!isWasmInitialized) {
36687 throw new Error("initializeWasm() must be awaited first!");
36689 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
36690 // debug statements here
36692 // struct LDKCOption_u64Z UpdateAddHTLC_get_skimmed_fee_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
36694 export function UpdateAddHTLC_get_skimmed_fee_msat(this_ptr: bigint): bigint {
36695 if(!isWasmInitialized) {
36696 throw new Error("initializeWasm() must be awaited first!");
36698 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_skimmed_fee_msat(this_ptr);
36699 return nativeResponseValue;
36701 // void UpdateAddHTLC_set_skimmed_fee_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
36703 export function UpdateAddHTLC_set_skimmed_fee_msat(this_ptr: bigint, val: bigint): void {
36704 if(!isWasmInitialized) {
36705 throw new Error("initializeWasm() must be awaited first!");
36707 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_skimmed_fee_msat(this_ptr, val);
36708 // debug statements here
36710 // struct LDKOnionPacket UpdateAddHTLC_get_onion_routing_packet(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
36712 export function UpdateAddHTLC_get_onion_routing_packet(this_ptr: bigint): bigint {
36713 if(!isWasmInitialized) {
36714 throw new Error("initializeWasm() must be awaited first!");
36716 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_onion_routing_packet(this_ptr);
36717 return nativeResponseValue;
36719 // void UpdateAddHTLC_set_onion_routing_packet(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKOnionPacket val);
36721 export function UpdateAddHTLC_set_onion_routing_packet(this_ptr: bigint, val: bigint): void {
36722 if(!isWasmInitialized) {
36723 throw new Error("initializeWasm() must be awaited first!");
36725 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_onion_routing_packet(this_ptr, val);
36726 // debug statements here
36728 // struct LDKPublicKey UpdateAddHTLC_get_blinding_point(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
36730 export function UpdateAddHTLC_get_blinding_point(this_ptr: bigint): number {
36731 if(!isWasmInitialized) {
36732 throw new Error("initializeWasm() must be awaited first!");
36734 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_blinding_point(this_ptr);
36735 return nativeResponseValue;
36737 // void UpdateAddHTLC_set_blinding_point(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36739 export function UpdateAddHTLC_set_blinding_point(this_ptr: bigint, val: number): void {
36740 if(!isWasmInitialized) {
36741 throw new Error("initializeWasm() must be awaited first!");
36743 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_blinding_point(this_ptr, val);
36744 // debug statements here
36746 // MUST_USE_RES struct LDKUpdateAddHTLC UpdateAddHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, uint64_t amount_msat_arg, struct LDKThirtyTwoBytes payment_hash_arg, uint32_t cltv_expiry_arg, struct LDKCOption_u64Z skimmed_fee_msat_arg, struct LDKOnionPacket onion_routing_packet_arg, struct LDKPublicKey blinding_point_arg);
36748 export function UpdateAddHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, amount_msat_arg: bigint, payment_hash_arg: number, cltv_expiry_arg: number, skimmed_fee_msat_arg: bigint, onion_routing_packet_arg: bigint, blinding_point_arg: number): bigint {
36749 if(!isWasmInitialized) {
36750 throw new Error("initializeWasm() must be awaited first!");
36752 const nativeResponseValue = wasm.TS_UpdateAddHTLC_new(channel_id_arg, htlc_id_arg, amount_msat_arg, payment_hash_arg, cltv_expiry_arg, skimmed_fee_msat_arg, onion_routing_packet_arg, blinding_point_arg);
36753 return nativeResponseValue;
36755 // uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
36757 export function UpdateAddHTLC_clone_ptr(arg: bigint): bigint {
36758 if(!isWasmInitialized) {
36759 throw new Error("initializeWasm() must be awaited first!");
36761 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
36762 return nativeResponseValue;
36764 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
36766 export function UpdateAddHTLC_clone(orig: bigint): bigint {
36767 if(!isWasmInitialized) {
36768 throw new Error("initializeWasm() must be awaited first!");
36770 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
36771 return nativeResponseValue;
36773 // uint64_t UpdateAddHTLC_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR o);
36775 export function UpdateAddHTLC_hash(o: bigint): bigint {
36776 if(!isWasmInitialized) {
36777 throw new Error("initializeWasm() must be awaited first!");
36779 const nativeResponseValue = wasm.TS_UpdateAddHTLC_hash(o);
36780 return nativeResponseValue;
36782 // bool UpdateAddHTLC_eq(const struct LDKUpdateAddHTLC *NONNULL_PTR a, const struct LDKUpdateAddHTLC *NONNULL_PTR b);
36784 export function UpdateAddHTLC_eq(a: bigint, b: bigint): boolean {
36785 if(!isWasmInitialized) {
36786 throw new Error("initializeWasm() must be awaited first!");
36788 const nativeResponseValue = wasm.TS_UpdateAddHTLC_eq(a, b);
36789 return nativeResponseValue;
36791 // void OnionMessage_free(struct LDKOnionMessage this_obj);
36793 export function OnionMessage_free(this_obj: bigint): void {
36794 if(!isWasmInitialized) {
36795 throw new Error("initializeWasm() must be awaited first!");
36797 const nativeResponseValue = wasm.TS_OnionMessage_free(this_obj);
36798 // debug statements here
36800 // struct LDKPublicKey OnionMessage_get_blinding_point(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
36802 export function OnionMessage_get_blinding_point(this_ptr: bigint): number {
36803 if(!isWasmInitialized) {
36804 throw new Error("initializeWasm() must be awaited first!");
36806 const nativeResponseValue = wasm.TS_OnionMessage_get_blinding_point(this_ptr);
36807 return nativeResponseValue;
36809 // void OnionMessage_set_blinding_point(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPublicKey val);
36811 export function OnionMessage_set_blinding_point(this_ptr: bigint, val: number): void {
36812 if(!isWasmInitialized) {
36813 throw new Error("initializeWasm() must be awaited first!");
36815 const nativeResponseValue = wasm.TS_OnionMessage_set_blinding_point(this_ptr, val);
36816 // debug statements here
36818 // struct LDKPacket OnionMessage_get_onion_routing_packet(const struct LDKOnionMessage *NONNULL_PTR this_ptr);
36820 export function OnionMessage_get_onion_routing_packet(this_ptr: bigint): bigint {
36821 if(!isWasmInitialized) {
36822 throw new Error("initializeWasm() must be awaited first!");
36824 const nativeResponseValue = wasm.TS_OnionMessage_get_onion_routing_packet(this_ptr);
36825 return nativeResponseValue;
36827 // void OnionMessage_set_onion_routing_packet(struct LDKOnionMessage *NONNULL_PTR this_ptr, struct LDKPacket val);
36829 export function OnionMessage_set_onion_routing_packet(this_ptr: bigint, val: bigint): void {
36830 if(!isWasmInitialized) {
36831 throw new Error("initializeWasm() must be awaited first!");
36833 const nativeResponseValue = wasm.TS_OnionMessage_set_onion_routing_packet(this_ptr, val);
36834 // debug statements here
36836 // MUST_USE_RES struct LDKOnionMessage OnionMessage_new(struct LDKPublicKey blinding_point_arg, struct LDKPacket onion_routing_packet_arg);
36838 export function OnionMessage_new(blinding_point_arg: number, onion_routing_packet_arg: bigint): bigint {
36839 if(!isWasmInitialized) {
36840 throw new Error("initializeWasm() must be awaited first!");
36842 const nativeResponseValue = wasm.TS_OnionMessage_new(blinding_point_arg, onion_routing_packet_arg);
36843 return nativeResponseValue;
36845 // uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg);
36847 export function OnionMessage_clone_ptr(arg: bigint): bigint {
36848 if(!isWasmInitialized) {
36849 throw new Error("initializeWasm() must be awaited first!");
36851 const nativeResponseValue = wasm.TS_OnionMessage_clone_ptr(arg);
36852 return nativeResponseValue;
36854 // struct LDKOnionMessage OnionMessage_clone(const struct LDKOnionMessage *NONNULL_PTR orig);
36856 export function OnionMessage_clone(orig: bigint): bigint {
36857 if(!isWasmInitialized) {
36858 throw new Error("initializeWasm() must be awaited first!");
36860 const nativeResponseValue = wasm.TS_OnionMessage_clone(orig);
36861 return nativeResponseValue;
36863 // uint64_t OnionMessage_hash(const struct LDKOnionMessage *NONNULL_PTR o);
36865 export function OnionMessage_hash(o: bigint): bigint {
36866 if(!isWasmInitialized) {
36867 throw new Error("initializeWasm() must be awaited first!");
36869 const nativeResponseValue = wasm.TS_OnionMessage_hash(o);
36870 return nativeResponseValue;
36872 // bool OnionMessage_eq(const struct LDKOnionMessage *NONNULL_PTR a, const struct LDKOnionMessage *NONNULL_PTR b);
36874 export function OnionMessage_eq(a: bigint, b: bigint): boolean {
36875 if(!isWasmInitialized) {
36876 throw new Error("initializeWasm() must be awaited first!");
36878 const nativeResponseValue = wasm.TS_OnionMessage_eq(a, b);
36879 return nativeResponseValue;
36881 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
36883 export function UpdateFulfillHTLC_free(this_obj: bigint): void {
36884 if(!isWasmInitialized) {
36885 throw new Error("initializeWasm() must be awaited first!");
36887 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
36888 // debug statements here
36890 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
36892 export function UpdateFulfillHTLC_get_channel_id(this_ptr: bigint): number {
36893 if(!isWasmInitialized) {
36894 throw new Error("initializeWasm() must be awaited first!");
36896 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
36897 return nativeResponseValue;
36899 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
36901 export function UpdateFulfillHTLC_set_channel_id(this_ptr: bigint, val: number): void {
36902 if(!isWasmInitialized) {
36903 throw new Error("initializeWasm() must be awaited first!");
36905 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
36906 // debug statements here
36908 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
36910 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: bigint): bigint {
36911 if(!isWasmInitialized) {
36912 throw new Error("initializeWasm() must be awaited first!");
36914 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
36915 return nativeResponseValue;
36917 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
36919 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
36920 if(!isWasmInitialized) {
36921 throw new Error("initializeWasm() must be awaited first!");
36923 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
36924 // debug statements here
36926 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
36928 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: bigint): number {
36929 if(!isWasmInitialized) {
36930 throw new Error("initializeWasm() must be awaited first!");
36932 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
36933 return nativeResponseValue;
36935 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
36937 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: bigint, val: number): void {
36938 if(!isWasmInitialized) {
36939 throw new Error("initializeWasm() must be awaited first!");
36941 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
36942 // debug statements here
36944 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
36946 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): bigint {
36947 if(!isWasmInitialized) {
36948 throw new Error("initializeWasm() must be awaited first!");
36950 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
36951 return nativeResponseValue;
36953 // uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
36955 export function UpdateFulfillHTLC_clone_ptr(arg: bigint): bigint {
36956 if(!isWasmInitialized) {
36957 throw new Error("initializeWasm() must be awaited first!");
36959 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
36960 return nativeResponseValue;
36962 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
36964 export function UpdateFulfillHTLC_clone(orig: bigint): bigint {
36965 if(!isWasmInitialized) {
36966 throw new Error("initializeWasm() must be awaited first!");
36968 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
36969 return nativeResponseValue;
36971 // uint64_t UpdateFulfillHTLC_hash(const struct LDKUpdateFulfillHTLC *NONNULL_PTR o);
36973 export function UpdateFulfillHTLC_hash(o: bigint): bigint {
36974 if(!isWasmInitialized) {
36975 throw new Error("initializeWasm() must be awaited first!");
36977 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_hash(o);
36978 return nativeResponseValue;
36980 // bool UpdateFulfillHTLC_eq(const struct LDKUpdateFulfillHTLC *NONNULL_PTR a, const struct LDKUpdateFulfillHTLC *NONNULL_PTR b);
36982 export function UpdateFulfillHTLC_eq(a: bigint, b: bigint): boolean {
36983 if(!isWasmInitialized) {
36984 throw new Error("initializeWasm() must be awaited first!");
36986 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_eq(a, b);
36987 return nativeResponseValue;
36989 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
36991 export function UpdateFailHTLC_free(this_obj: bigint): void {
36992 if(!isWasmInitialized) {
36993 throw new Error("initializeWasm() must be awaited first!");
36995 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
36996 // debug statements here
36998 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
37000 export function UpdateFailHTLC_get_channel_id(this_ptr: bigint): number {
37001 if(!isWasmInitialized) {
37002 throw new Error("initializeWasm() must be awaited first!");
37004 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
37005 return nativeResponseValue;
37007 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37009 export function UpdateFailHTLC_set_channel_id(this_ptr: bigint, val: number): void {
37010 if(!isWasmInitialized) {
37011 throw new Error("initializeWasm() must be awaited first!");
37013 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
37014 // debug statements here
37016 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
37018 export function UpdateFailHTLC_get_htlc_id(this_ptr: bigint): bigint {
37019 if(!isWasmInitialized) {
37020 throw new Error("initializeWasm() must be awaited first!");
37022 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
37023 return nativeResponseValue;
37025 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
37027 export function UpdateFailHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
37028 if(!isWasmInitialized) {
37029 throw new Error("initializeWasm() must be awaited first!");
37031 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
37032 // debug statements here
37034 // uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
37036 export function UpdateFailHTLC_clone_ptr(arg: bigint): bigint {
37037 if(!isWasmInitialized) {
37038 throw new Error("initializeWasm() must be awaited first!");
37040 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
37041 return nativeResponseValue;
37043 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
37045 export function UpdateFailHTLC_clone(orig: bigint): bigint {
37046 if(!isWasmInitialized) {
37047 throw new Error("initializeWasm() must be awaited first!");
37049 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
37050 return nativeResponseValue;
37052 // uint64_t UpdateFailHTLC_hash(const struct LDKUpdateFailHTLC *NONNULL_PTR o);
37054 export function UpdateFailHTLC_hash(o: bigint): bigint {
37055 if(!isWasmInitialized) {
37056 throw new Error("initializeWasm() must be awaited first!");
37058 const nativeResponseValue = wasm.TS_UpdateFailHTLC_hash(o);
37059 return nativeResponseValue;
37061 // bool UpdateFailHTLC_eq(const struct LDKUpdateFailHTLC *NONNULL_PTR a, const struct LDKUpdateFailHTLC *NONNULL_PTR b);
37063 export function UpdateFailHTLC_eq(a: bigint, b: bigint): boolean {
37064 if(!isWasmInitialized) {
37065 throw new Error("initializeWasm() must be awaited first!");
37067 const nativeResponseValue = wasm.TS_UpdateFailHTLC_eq(a, b);
37068 return nativeResponseValue;
37070 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
37072 export function UpdateFailMalformedHTLC_free(this_obj: bigint): void {
37073 if(!isWasmInitialized) {
37074 throw new Error("initializeWasm() must be awaited first!");
37076 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
37077 // debug statements here
37079 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
37081 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: bigint): number {
37082 if(!isWasmInitialized) {
37083 throw new Error("initializeWasm() must be awaited first!");
37085 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
37086 return nativeResponseValue;
37088 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37090 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
37091 if(!isWasmInitialized) {
37092 throw new Error("initializeWasm() must be awaited first!");
37094 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
37095 // debug statements here
37097 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
37099 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: bigint): bigint {
37100 if(!isWasmInitialized) {
37101 throw new Error("initializeWasm() must be awaited first!");
37103 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
37104 return nativeResponseValue;
37106 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
37108 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: bigint, val: bigint): void {
37109 if(!isWasmInitialized) {
37110 throw new Error("initializeWasm() must be awaited first!");
37112 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
37113 // debug statements here
37115 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
37117 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: bigint): number {
37118 if(!isWasmInitialized) {
37119 throw new Error("initializeWasm() must be awaited first!");
37121 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
37122 return nativeResponseValue;
37124 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
37126 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: bigint, val: number): void {
37127 if(!isWasmInitialized) {
37128 throw new Error("initializeWasm() must be awaited first!");
37130 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
37131 // debug statements here
37133 // uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
37135 export function UpdateFailMalformedHTLC_clone_ptr(arg: bigint): bigint {
37136 if(!isWasmInitialized) {
37137 throw new Error("initializeWasm() must be awaited first!");
37139 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
37140 return nativeResponseValue;
37142 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
37144 export function UpdateFailMalformedHTLC_clone(orig: bigint): bigint {
37145 if(!isWasmInitialized) {
37146 throw new Error("initializeWasm() must be awaited first!");
37148 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
37149 return nativeResponseValue;
37151 // uint64_t UpdateFailMalformedHTLC_hash(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR o);
37153 export function UpdateFailMalformedHTLC_hash(o: bigint): bigint {
37154 if(!isWasmInitialized) {
37155 throw new Error("initializeWasm() must be awaited first!");
37157 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_hash(o);
37158 return nativeResponseValue;
37160 // bool UpdateFailMalformedHTLC_eq(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR a, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR b);
37162 export function UpdateFailMalformedHTLC_eq(a: bigint, b: bigint): boolean {
37163 if(!isWasmInitialized) {
37164 throw new Error("initializeWasm() must be awaited first!");
37166 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_eq(a, b);
37167 return nativeResponseValue;
37169 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
37171 export function CommitmentSigned_free(this_obj: bigint): void {
37172 if(!isWasmInitialized) {
37173 throw new Error("initializeWasm() must be awaited first!");
37175 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
37176 // debug statements here
37178 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
37180 export function CommitmentSigned_get_channel_id(this_ptr: bigint): number {
37181 if(!isWasmInitialized) {
37182 throw new Error("initializeWasm() must be awaited first!");
37184 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
37185 return nativeResponseValue;
37187 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37189 export function CommitmentSigned_set_channel_id(this_ptr: bigint, val: number): void {
37190 if(!isWasmInitialized) {
37191 throw new Error("initializeWasm() must be awaited first!");
37193 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
37194 // debug statements here
37196 // struct LDKECDSASignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
37198 export function CommitmentSigned_get_signature(this_ptr: bigint): number {
37199 if(!isWasmInitialized) {
37200 throw new Error("initializeWasm() must be awaited first!");
37202 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
37203 return nativeResponseValue;
37205 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
37207 export function CommitmentSigned_set_signature(this_ptr: bigint, val: number): void {
37208 if(!isWasmInitialized) {
37209 throw new Error("initializeWasm() must be awaited first!");
37211 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
37212 // debug statements here
37214 // struct LDKCVec_ECDSASignatureZ CommitmentSigned_get_htlc_signatures(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
37216 export function CommitmentSigned_get_htlc_signatures(this_ptr: bigint): number {
37217 if(!isWasmInitialized) {
37218 throw new Error("initializeWasm() must be awaited first!");
37220 const nativeResponseValue = wasm.TS_CommitmentSigned_get_htlc_signatures(this_ptr);
37221 return nativeResponseValue;
37223 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_ECDSASignatureZ val);
37225 export function CommitmentSigned_set_htlc_signatures(this_ptr: bigint, val: number): void {
37226 if(!isWasmInitialized) {
37227 throw new Error("initializeWasm() must be awaited first!");
37229 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
37230 // debug statements here
37232 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKECDSASignature signature_arg, struct LDKCVec_ECDSASignatureZ htlc_signatures_arg);
37234 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): bigint {
37235 if(!isWasmInitialized) {
37236 throw new Error("initializeWasm() must be awaited first!");
37238 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
37239 return nativeResponseValue;
37241 // uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
37243 export function CommitmentSigned_clone_ptr(arg: bigint): bigint {
37244 if(!isWasmInitialized) {
37245 throw new Error("initializeWasm() must be awaited first!");
37247 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
37248 return nativeResponseValue;
37250 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
37252 export function CommitmentSigned_clone(orig: bigint): bigint {
37253 if(!isWasmInitialized) {
37254 throw new Error("initializeWasm() must be awaited first!");
37256 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
37257 return nativeResponseValue;
37259 // uint64_t CommitmentSigned_hash(const struct LDKCommitmentSigned *NONNULL_PTR o);
37261 export function CommitmentSigned_hash(o: bigint): bigint {
37262 if(!isWasmInitialized) {
37263 throw new Error("initializeWasm() must be awaited first!");
37265 const nativeResponseValue = wasm.TS_CommitmentSigned_hash(o);
37266 return nativeResponseValue;
37268 // bool CommitmentSigned_eq(const struct LDKCommitmentSigned *NONNULL_PTR a, const struct LDKCommitmentSigned *NONNULL_PTR b);
37270 export function CommitmentSigned_eq(a: bigint, b: bigint): boolean {
37271 if(!isWasmInitialized) {
37272 throw new Error("initializeWasm() must be awaited first!");
37274 const nativeResponseValue = wasm.TS_CommitmentSigned_eq(a, b);
37275 return nativeResponseValue;
37277 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
37279 export function RevokeAndACK_free(this_obj: bigint): void {
37280 if(!isWasmInitialized) {
37281 throw new Error("initializeWasm() must be awaited first!");
37283 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
37284 // debug statements here
37286 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
37288 export function RevokeAndACK_get_channel_id(this_ptr: bigint): number {
37289 if(!isWasmInitialized) {
37290 throw new Error("initializeWasm() must be awaited first!");
37292 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
37293 return nativeResponseValue;
37295 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37297 export function RevokeAndACK_set_channel_id(this_ptr: bigint, val: number): void {
37298 if(!isWasmInitialized) {
37299 throw new Error("initializeWasm() must be awaited first!");
37301 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
37302 // debug statements here
37304 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
37306 export function RevokeAndACK_get_per_commitment_secret(this_ptr: bigint): number {
37307 if(!isWasmInitialized) {
37308 throw new Error("initializeWasm() must be awaited first!");
37310 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
37311 return nativeResponseValue;
37313 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37315 export function RevokeAndACK_set_per_commitment_secret(this_ptr: bigint, val: number): void {
37316 if(!isWasmInitialized) {
37317 throw new Error("initializeWasm() must be awaited first!");
37319 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
37320 // debug statements here
37322 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
37324 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: bigint): number {
37325 if(!isWasmInitialized) {
37326 throw new Error("initializeWasm() must be awaited first!");
37328 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
37329 return nativeResponseValue;
37331 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37333 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: bigint, val: number): void {
37334 if(!isWasmInitialized) {
37335 throw new Error("initializeWasm() must be awaited first!");
37337 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
37338 // debug statements here
37340 // 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);
37342 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): bigint {
37343 if(!isWasmInitialized) {
37344 throw new Error("initializeWasm() must be awaited first!");
37346 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
37347 return nativeResponseValue;
37349 // uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
37351 export function RevokeAndACK_clone_ptr(arg: bigint): bigint {
37352 if(!isWasmInitialized) {
37353 throw new Error("initializeWasm() must be awaited first!");
37355 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
37356 return nativeResponseValue;
37358 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
37360 export function RevokeAndACK_clone(orig: bigint): bigint {
37361 if(!isWasmInitialized) {
37362 throw new Error("initializeWasm() must be awaited first!");
37364 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
37365 return nativeResponseValue;
37367 // uint64_t RevokeAndACK_hash(const struct LDKRevokeAndACK *NONNULL_PTR o);
37369 export function RevokeAndACK_hash(o: bigint): bigint {
37370 if(!isWasmInitialized) {
37371 throw new Error("initializeWasm() must be awaited first!");
37373 const nativeResponseValue = wasm.TS_RevokeAndACK_hash(o);
37374 return nativeResponseValue;
37376 // bool RevokeAndACK_eq(const struct LDKRevokeAndACK *NONNULL_PTR a, const struct LDKRevokeAndACK *NONNULL_PTR b);
37378 export function RevokeAndACK_eq(a: bigint, b: bigint): boolean {
37379 if(!isWasmInitialized) {
37380 throw new Error("initializeWasm() must be awaited first!");
37382 const nativeResponseValue = wasm.TS_RevokeAndACK_eq(a, b);
37383 return nativeResponseValue;
37385 // void UpdateFee_free(struct LDKUpdateFee this_obj);
37387 export function UpdateFee_free(this_obj: bigint): void {
37388 if(!isWasmInitialized) {
37389 throw new Error("initializeWasm() must be awaited first!");
37391 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
37392 // debug statements here
37394 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
37396 export function UpdateFee_get_channel_id(this_ptr: bigint): number {
37397 if(!isWasmInitialized) {
37398 throw new Error("initializeWasm() must be awaited first!");
37400 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
37401 return nativeResponseValue;
37403 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37405 export function UpdateFee_set_channel_id(this_ptr: bigint, val: number): void {
37406 if(!isWasmInitialized) {
37407 throw new Error("initializeWasm() must be awaited first!");
37409 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
37410 // debug statements here
37412 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
37414 export function UpdateFee_get_feerate_per_kw(this_ptr: bigint): number {
37415 if(!isWasmInitialized) {
37416 throw new Error("initializeWasm() must be awaited first!");
37418 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
37419 return nativeResponseValue;
37421 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
37423 export function UpdateFee_set_feerate_per_kw(this_ptr: bigint, val: number): void {
37424 if(!isWasmInitialized) {
37425 throw new Error("initializeWasm() must be awaited first!");
37427 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
37428 // debug statements here
37430 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
37432 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): bigint {
37433 if(!isWasmInitialized) {
37434 throw new Error("initializeWasm() must be awaited first!");
37436 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
37437 return nativeResponseValue;
37439 // uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
37441 export function UpdateFee_clone_ptr(arg: bigint): bigint {
37442 if(!isWasmInitialized) {
37443 throw new Error("initializeWasm() must be awaited first!");
37445 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
37446 return nativeResponseValue;
37448 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
37450 export function UpdateFee_clone(orig: bigint): bigint {
37451 if(!isWasmInitialized) {
37452 throw new Error("initializeWasm() must be awaited first!");
37454 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
37455 return nativeResponseValue;
37457 // uint64_t UpdateFee_hash(const struct LDKUpdateFee *NONNULL_PTR o);
37459 export function UpdateFee_hash(o: bigint): bigint {
37460 if(!isWasmInitialized) {
37461 throw new Error("initializeWasm() must be awaited first!");
37463 const nativeResponseValue = wasm.TS_UpdateFee_hash(o);
37464 return nativeResponseValue;
37466 // bool UpdateFee_eq(const struct LDKUpdateFee *NONNULL_PTR a, const struct LDKUpdateFee *NONNULL_PTR b);
37468 export function UpdateFee_eq(a: bigint, b: bigint): boolean {
37469 if(!isWasmInitialized) {
37470 throw new Error("initializeWasm() must be awaited first!");
37472 const nativeResponseValue = wasm.TS_UpdateFee_eq(a, b);
37473 return nativeResponseValue;
37475 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
37477 export function ChannelReestablish_free(this_obj: bigint): void {
37478 if(!isWasmInitialized) {
37479 throw new Error("initializeWasm() must be awaited first!");
37481 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
37482 // debug statements here
37484 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
37486 export function ChannelReestablish_get_channel_id(this_ptr: bigint): number {
37487 if(!isWasmInitialized) {
37488 throw new Error("initializeWasm() must be awaited first!");
37490 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
37491 return nativeResponseValue;
37493 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37495 export function ChannelReestablish_set_channel_id(this_ptr: bigint, val: number): void {
37496 if(!isWasmInitialized) {
37497 throw new Error("initializeWasm() must be awaited first!");
37499 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
37500 // debug statements here
37502 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
37504 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: bigint): bigint {
37505 if(!isWasmInitialized) {
37506 throw new Error("initializeWasm() must be awaited first!");
37508 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
37509 return nativeResponseValue;
37511 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
37513 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: bigint, val: bigint): void {
37514 if(!isWasmInitialized) {
37515 throw new Error("initializeWasm() must be awaited first!");
37517 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
37518 // debug statements here
37520 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
37522 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: bigint): bigint {
37523 if(!isWasmInitialized) {
37524 throw new Error("initializeWasm() must be awaited first!");
37526 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
37527 return nativeResponseValue;
37529 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
37531 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: bigint, val: bigint): void {
37532 if(!isWasmInitialized) {
37533 throw new Error("initializeWasm() must be awaited first!");
37535 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
37536 // debug statements here
37538 // const uint8_t (*ChannelReestablish_get_your_last_per_commitment_secret(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
37540 export function ChannelReestablish_get_your_last_per_commitment_secret(this_ptr: bigint): number {
37541 if(!isWasmInitialized) {
37542 throw new Error("initializeWasm() must be awaited first!");
37544 const nativeResponseValue = wasm.TS_ChannelReestablish_get_your_last_per_commitment_secret(this_ptr);
37545 return nativeResponseValue;
37547 // void ChannelReestablish_set_your_last_per_commitment_secret(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37549 export function ChannelReestablish_set_your_last_per_commitment_secret(this_ptr: bigint, val: number): void {
37550 if(!isWasmInitialized) {
37551 throw new Error("initializeWasm() must be awaited first!");
37553 const nativeResponseValue = wasm.TS_ChannelReestablish_set_your_last_per_commitment_secret(this_ptr, val);
37554 // debug statements here
37556 // struct LDKPublicKey ChannelReestablish_get_my_current_per_commitment_point(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
37558 export function ChannelReestablish_get_my_current_per_commitment_point(this_ptr: bigint): number {
37559 if(!isWasmInitialized) {
37560 throw new Error("initializeWasm() must be awaited first!");
37562 const nativeResponseValue = wasm.TS_ChannelReestablish_get_my_current_per_commitment_point(this_ptr);
37563 return nativeResponseValue;
37565 // void ChannelReestablish_set_my_current_per_commitment_point(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKPublicKey val);
37567 export function ChannelReestablish_set_my_current_per_commitment_point(this_ptr: bigint, val: number): void {
37568 if(!isWasmInitialized) {
37569 throw new Error("initializeWasm() must be awaited first!");
37571 const nativeResponseValue = wasm.TS_ChannelReestablish_set_my_current_per_commitment_point(this_ptr, val);
37572 // debug statements here
37574 // struct LDKCOption_ThirtyTwoBytesZ ChannelReestablish_get_next_funding_txid(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
37576 export function ChannelReestablish_get_next_funding_txid(this_ptr: bigint): bigint {
37577 if(!isWasmInitialized) {
37578 throw new Error("initializeWasm() must be awaited first!");
37580 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_funding_txid(this_ptr);
37581 return nativeResponseValue;
37583 // void ChannelReestablish_set_next_funding_txid(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
37585 export function ChannelReestablish_set_next_funding_txid(this_ptr: bigint, val: bigint): void {
37586 if(!isWasmInitialized) {
37587 throw new Error("initializeWasm() must be awaited first!");
37589 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_funding_txid(this_ptr, val);
37590 // debug statements here
37592 // 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);
37594 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 {
37595 if(!isWasmInitialized) {
37596 throw new Error("initializeWasm() must be awaited first!");
37598 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);
37599 return nativeResponseValue;
37601 // uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
37603 export function ChannelReestablish_clone_ptr(arg: bigint): bigint {
37604 if(!isWasmInitialized) {
37605 throw new Error("initializeWasm() must be awaited first!");
37607 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
37608 return nativeResponseValue;
37610 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
37612 export function ChannelReestablish_clone(orig: bigint): bigint {
37613 if(!isWasmInitialized) {
37614 throw new Error("initializeWasm() must be awaited first!");
37616 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
37617 return nativeResponseValue;
37619 // uint64_t ChannelReestablish_hash(const struct LDKChannelReestablish *NONNULL_PTR o);
37621 export function ChannelReestablish_hash(o: bigint): bigint {
37622 if(!isWasmInitialized) {
37623 throw new Error("initializeWasm() must be awaited first!");
37625 const nativeResponseValue = wasm.TS_ChannelReestablish_hash(o);
37626 return nativeResponseValue;
37628 // bool ChannelReestablish_eq(const struct LDKChannelReestablish *NONNULL_PTR a, const struct LDKChannelReestablish *NONNULL_PTR b);
37630 export function ChannelReestablish_eq(a: bigint, b: bigint): boolean {
37631 if(!isWasmInitialized) {
37632 throw new Error("initializeWasm() must be awaited first!");
37634 const nativeResponseValue = wasm.TS_ChannelReestablish_eq(a, b);
37635 return nativeResponseValue;
37637 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
37639 export function AnnouncementSignatures_free(this_obj: bigint): void {
37640 if(!isWasmInitialized) {
37641 throw new Error("initializeWasm() must be awaited first!");
37643 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
37644 // debug statements here
37646 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
37648 export function AnnouncementSignatures_get_channel_id(this_ptr: bigint): number {
37649 if(!isWasmInitialized) {
37650 throw new Error("initializeWasm() must be awaited first!");
37652 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
37653 return nativeResponseValue;
37655 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
37657 export function AnnouncementSignatures_set_channel_id(this_ptr: bigint, val: number): void {
37658 if(!isWasmInitialized) {
37659 throw new Error("initializeWasm() must be awaited first!");
37661 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
37662 // debug statements here
37664 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
37666 export function AnnouncementSignatures_get_short_channel_id(this_ptr: bigint): bigint {
37667 if(!isWasmInitialized) {
37668 throw new Error("initializeWasm() must be awaited first!");
37670 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
37671 return nativeResponseValue;
37673 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
37675 export function AnnouncementSignatures_set_short_channel_id(this_ptr: bigint, val: bigint): void {
37676 if(!isWasmInitialized) {
37677 throw new Error("initializeWasm() must be awaited first!");
37679 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
37680 // debug statements here
37682 // struct LDKECDSASignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
37684 export function AnnouncementSignatures_get_node_signature(this_ptr: bigint): number {
37685 if(!isWasmInitialized) {
37686 throw new Error("initializeWasm() must be awaited first!");
37688 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
37689 return nativeResponseValue;
37691 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
37693 export function AnnouncementSignatures_set_node_signature(this_ptr: bigint, val: number): void {
37694 if(!isWasmInitialized) {
37695 throw new Error("initializeWasm() must be awaited first!");
37697 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
37698 // debug statements here
37700 // struct LDKECDSASignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
37702 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: bigint): number {
37703 if(!isWasmInitialized) {
37704 throw new Error("initializeWasm() must be awaited first!");
37706 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
37707 return nativeResponseValue;
37709 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
37711 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: bigint, val: number): void {
37712 if(!isWasmInitialized) {
37713 throw new Error("initializeWasm() must be awaited first!");
37715 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
37716 // debug statements here
37718 // 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);
37720 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): bigint {
37721 if(!isWasmInitialized) {
37722 throw new Error("initializeWasm() must be awaited first!");
37724 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
37725 return nativeResponseValue;
37727 // uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
37729 export function AnnouncementSignatures_clone_ptr(arg: bigint): bigint {
37730 if(!isWasmInitialized) {
37731 throw new Error("initializeWasm() must be awaited first!");
37733 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
37734 return nativeResponseValue;
37736 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
37738 export function AnnouncementSignatures_clone(orig: bigint): bigint {
37739 if(!isWasmInitialized) {
37740 throw new Error("initializeWasm() must be awaited first!");
37742 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
37743 return nativeResponseValue;
37745 // uint64_t AnnouncementSignatures_hash(const struct LDKAnnouncementSignatures *NONNULL_PTR o);
37747 export function AnnouncementSignatures_hash(o: bigint): bigint {
37748 if(!isWasmInitialized) {
37749 throw new Error("initializeWasm() must be awaited first!");
37751 const nativeResponseValue = wasm.TS_AnnouncementSignatures_hash(o);
37752 return nativeResponseValue;
37754 // bool AnnouncementSignatures_eq(const struct LDKAnnouncementSignatures *NONNULL_PTR a, const struct LDKAnnouncementSignatures *NONNULL_PTR b);
37756 export function AnnouncementSignatures_eq(a: bigint, b: bigint): boolean {
37757 if(!isWasmInitialized) {
37758 throw new Error("initializeWasm() must be awaited first!");
37760 const nativeResponseValue = wasm.TS_AnnouncementSignatures_eq(a, b);
37761 return nativeResponseValue;
37763 // void SocketAddress_free(struct LDKSocketAddress this_ptr);
37765 export function SocketAddress_free(this_ptr: bigint): void {
37766 if(!isWasmInitialized) {
37767 throw new Error("initializeWasm() must be awaited first!");
37769 const nativeResponseValue = wasm.TS_SocketAddress_free(this_ptr);
37770 // debug statements here
37772 // uint64_t SocketAddress_clone_ptr(LDKSocketAddress *NONNULL_PTR arg);
37774 export function SocketAddress_clone_ptr(arg: bigint): bigint {
37775 if(!isWasmInitialized) {
37776 throw new Error("initializeWasm() must be awaited first!");
37778 const nativeResponseValue = wasm.TS_SocketAddress_clone_ptr(arg);
37779 return nativeResponseValue;
37781 // struct LDKSocketAddress SocketAddress_clone(const struct LDKSocketAddress *NONNULL_PTR orig);
37783 export function SocketAddress_clone(orig: bigint): bigint {
37784 if(!isWasmInitialized) {
37785 throw new Error("initializeWasm() must be awaited first!");
37787 const nativeResponseValue = wasm.TS_SocketAddress_clone(orig);
37788 return nativeResponseValue;
37790 // struct LDKSocketAddress SocketAddress_tcp_ip_v4(struct LDKFourBytes addr, uint16_t port);
37792 export function SocketAddress_tcp_ip_v4(addr: number, port: number): bigint {
37793 if(!isWasmInitialized) {
37794 throw new Error("initializeWasm() must be awaited first!");
37796 const nativeResponseValue = wasm.TS_SocketAddress_tcp_ip_v4(addr, port);
37797 return nativeResponseValue;
37799 // struct LDKSocketAddress SocketAddress_tcp_ip_v6(struct LDKSixteenBytes addr, uint16_t port);
37801 export function SocketAddress_tcp_ip_v6(addr: number, port: number): bigint {
37802 if(!isWasmInitialized) {
37803 throw new Error("initializeWasm() must be awaited first!");
37805 const nativeResponseValue = wasm.TS_SocketAddress_tcp_ip_v6(addr, port);
37806 return nativeResponseValue;
37808 // struct LDKSocketAddress SocketAddress_onion_v2(struct LDKTwelveBytes a);
37810 export function SocketAddress_onion_v2(a: number): bigint {
37811 if(!isWasmInitialized) {
37812 throw new Error("initializeWasm() must be awaited first!");
37814 const nativeResponseValue = wasm.TS_SocketAddress_onion_v2(a);
37815 return nativeResponseValue;
37817 // struct LDKSocketAddress SocketAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
37819 export function SocketAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): bigint {
37820 if(!isWasmInitialized) {
37821 throw new Error("initializeWasm() must be awaited first!");
37823 const nativeResponseValue = wasm.TS_SocketAddress_onion_v3(ed25519_pubkey, checksum, version, port);
37824 return nativeResponseValue;
37826 // struct LDKSocketAddress SocketAddress_hostname(struct LDKHostname hostname, uint16_t port);
37828 export function SocketAddress_hostname(hostname: bigint, port: number): bigint {
37829 if(!isWasmInitialized) {
37830 throw new Error("initializeWasm() must be awaited first!");
37832 const nativeResponseValue = wasm.TS_SocketAddress_hostname(hostname, port);
37833 return nativeResponseValue;
37835 // uint64_t SocketAddress_hash(const struct LDKSocketAddress *NONNULL_PTR o);
37837 export function SocketAddress_hash(o: bigint): bigint {
37838 if(!isWasmInitialized) {
37839 throw new Error("initializeWasm() must be awaited first!");
37841 const nativeResponseValue = wasm.TS_SocketAddress_hash(o);
37842 return nativeResponseValue;
37844 // bool SocketAddress_eq(const struct LDKSocketAddress *NONNULL_PTR a, const struct LDKSocketAddress *NONNULL_PTR b);
37846 export function SocketAddress_eq(a: bigint, b: bigint): boolean {
37847 if(!isWasmInitialized) {
37848 throw new Error("initializeWasm() must be awaited first!");
37850 const nativeResponseValue = wasm.TS_SocketAddress_eq(a, b);
37851 return nativeResponseValue;
37853 // struct LDKCVec_u8Z SocketAddress_write(const struct LDKSocketAddress *NONNULL_PTR obj);
37855 export function SocketAddress_write(obj: bigint): number {
37856 if(!isWasmInitialized) {
37857 throw new Error("initializeWasm() must be awaited first!");
37859 const nativeResponseValue = wasm.TS_SocketAddress_write(obj);
37860 return nativeResponseValue;
37862 // struct LDKCResult_SocketAddressDecodeErrorZ SocketAddress_read(struct LDKu8slice ser);
37864 export function SocketAddress_read(ser: number): bigint {
37865 if(!isWasmInitialized) {
37866 throw new Error("initializeWasm() must be awaited first!");
37868 const nativeResponseValue = wasm.TS_SocketAddress_read(ser);
37869 return nativeResponseValue;
37871 // enum LDKSocketAddressParseError SocketAddressParseError_clone(const enum LDKSocketAddressParseError *NONNULL_PTR orig);
37873 export function SocketAddressParseError_clone(orig: bigint): SocketAddressParseError {
37874 if(!isWasmInitialized) {
37875 throw new Error("initializeWasm() must be awaited first!");
37877 const nativeResponseValue = wasm.TS_SocketAddressParseError_clone(orig);
37878 return nativeResponseValue;
37880 // enum LDKSocketAddressParseError SocketAddressParseError_socket_addr_parse(void);
37882 export function SocketAddressParseError_socket_addr_parse(): SocketAddressParseError {
37883 if(!isWasmInitialized) {
37884 throw new Error("initializeWasm() must be awaited first!");
37886 const nativeResponseValue = wasm.TS_SocketAddressParseError_socket_addr_parse();
37887 return nativeResponseValue;
37889 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_input(void);
37891 export function SocketAddressParseError_invalid_input(): SocketAddressParseError {
37892 if(!isWasmInitialized) {
37893 throw new Error("initializeWasm() must be awaited first!");
37895 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_input();
37896 return nativeResponseValue;
37898 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_port(void);
37900 export function SocketAddressParseError_invalid_port(): SocketAddressParseError {
37901 if(!isWasmInitialized) {
37902 throw new Error("initializeWasm() must be awaited first!");
37904 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_port();
37905 return nativeResponseValue;
37907 // enum LDKSocketAddressParseError SocketAddressParseError_invalid_onion_v3(void);
37909 export function SocketAddressParseError_invalid_onion_v3(): SocketAddressParseError {
37910 if(!isWasmInitialized) {
37911 throw new Error("initializeWasm() must be awaited first!");
37913 const nativeResponseValue = wasm.TS_SocketAddressParseError_invalid_onion_v3();
37914 return nativeResponseValue;
37916 // uint64_t SocketAddressParseError_hash(const enum LDKSocketAddressParseError *NONNULL_PTR o);
37918 export function SocketAddressParseError_hash(o: bigint): bigint {
37919 if(!isWasmInitialized) {
37920 throw new Error("initializeWasm() must be awaited first!");
37922 const nativeResponseValue = wasm.TS_SocketAddressParseError_hash(o);
37923 return nativeResponseValue;
37925 // bool SocketAddressParseError_eq(const enum LDKSocketAddressParseError *NONNULL_PTR a, const enum LDKSocketAddressParseError *NONNULL_PTR b);
37927 export function SocketAddressParseError_eq(a: bigint, b: bigint): boolean {
37928 if(!isWasmInitialized) {
37929 throw new Error("initializeWasm() must be awaited first!");
37931 const nativeResponseValue = wasm.TS_SocketAddressParseError_eq(a, b);
37932 return nativeResponseValue;
37934 // struct LDKCResult_SocketAddressSocketAddressParseErrorZ parse_onion_address(struct LDKStr host, uint16_t port);
37936 export function parse_onion_address(host: number, port: number): bigint {
37937 if(!isWasmInitialized) {
37938 throw new Error("initializeWasm() must be awaited first!");
37940 const nativeResponseValue = wasm.TS_parse_onion_address(host, port);
37941 return nativeResponseValue;
37943 // struct LDKStr SocketAddress_to_str(const struct LDKSocketAddress *NONNULL_PTR o);
37945 export function SocketAddress_to_str(o: bigint): number {
37946 if(!isWasmInitialized) {
37947 throw new Error("initializeWasm() must be awaited first!");
37949 const nativeResponseValue = wasm.TS_SocketAddress_to_str(o);
37950 return nativeResponseValue;
37952 // void UnsignedGossipMessage_free(struct LDKUnsignedGossipMessage this_ptr);
37954 export function UnsignedGossipMessage_free(this_ptr: bigint): void {
37955 if(!isWasmInitialized) {
37956 throw new Error("initializeWasm() must be awaited first!");
37958 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_free(this_ptr);
37959 // debug statements here
37961 // uint64_t UnsignedGossipMessage_clone_ptr(LDKUnsignedGossipMessage *NONNULL_PTR arg);
37963 export function UnsignedGossipMessage_clone_ptr(arg: bigint): bigint {
37964 if(!isWasmInitialized) {
37965 throw new Error("initializeWasm() must be awaited first!");
37967 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone_ptr(arg);
37968 return nativeResponseValue;
37970 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_clone(const struct LDKUnsignedGossipMessage *NONNULL_PTR orig);
37972 export function UnsignedGossipMessage_clone(orig: bigint): bigint {
37973 if(!isWasmInitialized) {
37974 throw new Error("initializeWasm() must be awaited first!");
37976 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_clone(orig);
37977 return nativeResponseValue;
37979 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_announcement(struct LDKUnsignedChannelAnnouncement a);
37981 export function UnsignedGossipMessage_channel_announcement(a: bigint): bigint {
37982 if(!isWasmInitialized) {
37983 throw new Error("initializeWasm() must be awaited first!");
37985 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_announcement(a);
37986 return nativeResponseValue;
37988 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_channel_update(struct LDKUnsignedChannelUpdate a);
37990 export function UnsignedGossipMessage_channel_update(a: bigint): bigint {
37991 if(!isWasmInitialized) {
37992 throw new Error("initializeWasm() must be awaited first!");
37994 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_channel_update(a);
37995 return nativeResponseValue;
37997 // struct LDKUnsignedGossipMessage UnsignedGossipMessage_node_announcement(struct LDKUnsignedNodeAnnouncement a);
37999 export function UnsignedGossipMessage_node_announcement(a: bigint): bigint {
38000 if(!isWasmInitialized) {
38001 throw new Error("initializeWasm() must be awaited first!");
38003 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_node_announcement(a);
38004 return nativeResponseValue;
38006 // struct LDKCVec_u8Z UnsignedGossipMessage_write(const struct LDKUnsignedGossipMessage *NONNULL_PTR obj);
38008 export function UnsignedGossipMessage_write(obj: bigint): number {
38009 if(!isWasmInitialized) {
38010 throw new Error("initializeWasm() must be awaited first!");
38012 const nativeResponseValue = wasm.TS_UnsignedGossipMessage_write(obj);
38013 return nativeResponseValue;
38015 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
38017 export function UnsignedNodeAnnouncement_free(this_obj: bigint): void {
38018 if(!isWasmInitialized) {
38019 throw new Error("initializeWasm() must be awaited first!");
38021 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
38022 // debug statements here
38024 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
38026 export function UnsignedNodeAnnouncement_get_features(this_ptr: bigint): bigint {
38027 if(!isWasmInitialized) {
38028 throw new Error("initializeWasm() must be awaited first!");
38030 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
38031 return nativeResponseValue;
38033 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
38035 export function UnsignedNodeAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
38036 if(!isWasmInitialized) {
38037 throw new Error("initializeWasm() must be awaited first!");
38039 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
38040 // debug statements here
38042 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
38044 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: bigint): number {
38045 if(!isWasmInitialized) {
38046 throw new Error("initializeWasm() must be awaited first!");
38048 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
38049 return nativeResponseValue;
38051 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
38053 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: bigint, val: number): void {
38054 if(!isWasmInitialized) {
38055 throw new Error("initializeWasm() must be awaited first!");
38057 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
38058 // debug statements here
38060 // struct LDKNodeId UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
38062 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: bigint): bigint {
38063 if(!isWasmInitialized) {
38064 throw new Error("initializeWasm() must be awaited first!");
38066 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
38067 return nativeResponseValue;
38069 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
38071 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: bigint, val: bigint): void {
38072 if(!isWasmInitialized) {
38073 throw new Error("initializeWasm() must be awaited first!");
38075 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
38076 // debug statements here
38078 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
38080 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: bigint): number {
38081 if(!isWasmInitialized) {
38082 throw new Error("initializeWasm() must be awaited first!");
38084 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
38085 return nativeResponseValue;
38087 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
38089 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: bigint, val: number): void {
38090 if(!isWasmInitialized) {
38091 throw new Error("initializeWasm() must be awaited first!");
38093 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
38094 // debug statements here
38096 // struct LDKNodeAlias UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
38098 export function UnsignedNodeAnnouncement_get_alias(this_ptr: bigint): bigint {
38099 if(!isWasmInitialized) {
38100 throw new Error("initializeWasm() must be awaited first!");
38102 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
38103 return nativeResponseValue;
38105 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
38107 export function UnsignedNodeAnnouncement_set_alias(this_ptr: bigint, val: bigint): void {
38108 if(!isWasmInitialized) {
38109 throw new Error("initializeWasm() must be awaited first!");
38111 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
38112 // debug statements here
38114 // struct LDKCVec_SocketAddressZ UnsignedNodeAnnouncement_get_addresses(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
38116 export function UnsignedNodeAnnouncement_get_addresses(this_ptr: bigint): number {
38117 if(!isWasmInitialized) {
38118 throw new Error("initializeWasm() must be awaited first!");
38120 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_addresses(this_ptr);
38121 return nativeResponseValue;
38123 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_SocketAddressZ val);
38125 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: bigint, val: number): void {
38126 if(!isWasmInitialized) {
38127 throw new Error("initializeWasm() must be awaited first!");
38129 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
38130 // debug statements here
38132 // uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
38134 export function UnsignedNodeAnnouncement_clone_ptr(arg: bigint): bigint {
38135 if(!isWasmInitialized) {
38136 throw new Error("initializeWasm() must be awaited first!");
38138 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
38139 return nativeResponseValue;
38141 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
38143 export function UnsignedNodeAnnouncement_clone(orig: bigint): bigint {
38144 if(!isWasmInitialized) {
38145 throw new Error("initializeWasm() must be awaited first!");
38147 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
38148 return nativeResponseValue;
38150 // uint64_t UnsignedNodeAnnouncement_hash(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR o);
38152 export function UnsignedNodeAnnouncement_hash(o: bigint): bigint {
38153 if(!isWasmInitialized) {
38154 throw new Error("initializeWasm() must be awaited first!");
38156 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_hash(o);
38157 return nativeResponseValue;
38159 // bool UnsignedNodeAnnouncement_eq(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR a, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR b);
38161 export function UnsignedNodeAnnouncement_eq(a: bigint, b: bigint): boolean {
38162 if(!isWasmInitialized) {
38163 throw new Error("initializeWasm() must be awaited first!");
38165 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_eq(a, b);
38166 return nativeResponseValue;
38168 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
38170 export function NodeAnnouncement_free(this_obj: bigint): void {
38171 if(!isWasmInitialized) {
38172 throw new Error("initializeWasm() must be awaited first!");
38174 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
38175 // debug statements here
38177 // struct LDKECDSASignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
38179 export function NodeAnnouncement_get_signature(this_ptr: bigint): number {
38180 if(!isWasmInitialized) {
38181 throw new Error("initializeWasm() must be awaited first!");
38183 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
38184 return nativeResponseValue;
38186 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
38188 export function NodeAnnouncement_set_signature(this_ptr: bigint, val: number): void {
38189 if(!isWasmInitialized) {
38190 throw new Error("initializeWasm() must be awaited first!");
38192 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
38193 // debug statements here
38195 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
38197 export function NodeAnnouncement_get_contents(this_ptr: bigint): bigint {
38198 if(!isWasmInitialized) {
38199 throw new Error("initializeWasm() must be awaited first!");
38201 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
38202 return nativeResponseValue;
38204 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
38206 export function NodeAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
38207 if(!isWasmInitialized) {
38208 throw new Error("initializeWasm() must be awaited first!");
38210 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
38211 // debug statements here
38213 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKECDSASignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
38215 export function NodeAnnouncement_new(signature_arg: number, contents_arg: bigint): bigint {
38216 if(!isWasmInitialized) {
38217 throw new Error("initializeWasm() must be awaited first!");
38219 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
38220 return nativeResponseValue;
38222 // uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
38224 export function NodeAnnouncement_clone_ptr(arg: bigint): bigint {
38225 if(!isWasmInitialized) {
38226 throw new Error("initializeWasm() must be awaited first!");
38228 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
38229 return nativeResponseValue;
38231 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
38233 export function NodeAnnouncement_clone(orig: bigint): bigint {
38234 if(!isWasmInitialized) {
38235 throw new Error("initializeWasm() must be awaited first!");
38237 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
38238 return nativeResponseValue;
38240 // uint64_t NodeAnnouncement_hash(const struct LDKNodeAnnouncement *NONNULL_PTR o);
38242 export function NodeAnnouncement_hash(o: bigint): bigint {
38243 if(!isWasmInitialized) {
38244 throw new Error("initializeWasm() must be awaited first!");
38246 const nativeResponseValue = wasm.TS_NodeAnnouncement_hash(o);
38247 return nativeResponseValue;
38249 // bool NodeAnnouncement_eq(const struct LDKNodeAnnouncement *NONNULL_PTR a, const struct LDKNodeAnnouncement *NONNULL_PTR b);
38251 export function NodeAnnouncement_eq(a: bigint, b: bigint): boolean {
38252 if(!isWasmInitialized) {
38253 throw new Error("initializeWasm() must be awaited first!");
38255 const nativeResponseValue = wasm.TS_NodeAnnouncement_eq(a, b);
38256 return nativeResponseValue;
38258 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
38260 export function UnsignedChannelAnnouncement_free(this_obj: bigint): void {
38261 if(!isWasmInitialized) {
38262 throw new Error("initializeWasm() must be awaited first!");
38264 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
38265 // debug statements here
38267 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
38269 export function UnsignedChannelAnnouncement_get_features(this_ptr: bigint): bigint {
38270 if(!isWasmInitialized) {
38271 throw new Error("initializeWasm() must be awaited first!");
38273 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
38274 return nativeResponseValue;
38276 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
38278 export function UnsignedChannelAnnouncement_set_features(this_ptr: bigint, val: bigint): void {
38279 if(!isWasmInitialized) {
38280 throw new Error("initializeWasm() must be awaited first!");
38282 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
38283 // debug statements here
38285 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
38287 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: bigint): number {
38288 if(!isWasmInitialized) {
38289 throw new Error("initializeWasm() must be awaited first!");
38291 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
38292 return nativeResponseValue;
38294 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
38296 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: bigint, val: number): void {
38297 if(!isWasmInitialized) {
38298 throw new Error("initializeWasm() must be awaited first!");
38300 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
38301 // debug statements here
38303 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
38305 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: bigint): bigint {
38306 if(!isWasmInitialized) {
38307 throw new Error("initializeWasm() must be awaited first!");
38309 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
38310 return nativeResponseValue;
38312 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
38314 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: bigint, val: bigint): void {
38315 if(!isWasmInitialized) {
38316 throw new Error("initializeWasm() must be awaited first!");
38318 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
38319 // debug statements here
38321 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
38323 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: bigint): bigint {
38324 if(!isWasmInitialized) {
38325 throw new Error("initializeWasm() must be awaited first!");
38327 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
38328 return nativeResponseValue;
38330 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
38332 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: bigint, val: bigint): void {
38333 if(!isWasmInitialized) {
38334 throw new Error("initializeWasm() must be awaited first!");
38336 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
38337 // debug statements here
38339 // struct LDKNodeId UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
38341 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: bigint): bigint {
38342 if(!isWasmInitialized) {
38343 throw new Error("initializeWasm() must be awaited first!");
38345 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
38346 return nativeResponseValue;
38348 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
38350 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: bigint, val: bigint): void {
38351 if(!isWasmInitialized) {
38352 throw new Error("initializeWasm() must be awaited first!");
38354 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
38355 // debug statements here
38357 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
38359 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: bigint): bigint {
38360 if(!isWasmInitialized) {
38361 throw new Error("initializeWasm() must be awaited first!");
38363 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
38364 return nativeResponseValue;
38366 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
38368 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: bigint, val: bigint): void {
38369 if(!isWasmInitialized) {
38370 throw new Error("initializeWasm() must be awaited first!");
38372 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
38373 // debug statements here
38375 // struct LDKNodeId UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
38377 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: bigint): bigint {
38378 if(!isWasmInitialized) {
38379 throw new Error("initializeWasm() must be awaited first!");
38381 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
38382 return nativeResponseValue;
38384 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeId val);
38386 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: bigint, val: bigint): void {
38387 if(!isWasmInitialized) {
38388 throw new Error("initializeWasm() must be awaited first!");
38390 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
38391 // debug statements here
38393 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_get_excess_data(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
38395 export function UnsignedChannelAnnouncement_get_excess_data(this_ptr: bigint): number {
38396 if(!isWasmInitialized) {
38397 throw new Error("initializeWasm() must be awaited first!");
38399 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_excess_data(this_ptr);
38400 return nativeResponseValue;
38402 // void UnsignedChannelAnnouncement_set_excess_data(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
38404 export function UnsignedChannelAnnouncement_set_excess_data(this_ptr: bigint, val: number): void {
38405 if(!isWasmInitialized) {
38406 throw new Error("initializeWasm() must be awaited first!");
38408 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_excess_data(this_ptr, val);
38409 // debug statements here
38411 // 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);
38413 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 {
38414 if(!isWasmInitialized) {
38415 throw new Error("initializeWasm() must be awaited first!");
38417 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);
38418 return nativeResponseValue;
38420 // uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
38422 export function UnsignedChannelAnnouncement_clone_ptr(arg: bigint): bigint {
38423 if(!isWasmInitialized) {
38424 throw new Error("initializeWasm() must be awaited first!");
38426 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
38427 return nativeResponseValue;
38429 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
38431 export function UnsignedChannelAnnouncement_clone(orig: bigint): bigint {
38432 if(!isWasmInitialized) {
38433 throw new Error("initializeWasm() must be awaited first!");
38435 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
38436 return nativeResponseValue;
38438 // uint64_t UnsignedChannelAnnouncement_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR o);
38440 export function UnsignedChannelAnnouncement_hash(o: bigint): bigint {
38441 if(!isWasmInitialized) {
38442 throw new Error("initializeWasm() must be awaited first!");
38444 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_hash(o);
38445 return nativeResponseValue;
38447 // bool UnsignedChannelAnnouncement_eq(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR a, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR b);
38449 export function UnsignedChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
38450 if(!isWasmInitialized) {
38451 throw new Error("initializeWasm() must be awaited first!");
38453 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_eq(a, b);
38454 return nativeResponseValue;
38456 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
38458 export function ChannelAnnouncement_free(this_obj: bigint): void {
38459 if(!isWasmInitialized) {
38460 throw new Error("initializeWasm() must be awaited first!");
38462 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
38463 // debug statements here
38465 // struct LDKECDSASignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
38467 export function ChannelAnnouncement_get_node_signature_1(this_ptr: bigint): number {
38468 if(!isWasmInitialized) {
38469 throw new Error("initializeWasm() must be awaited first!");
38471 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
38472 return nativeResponseValue;
38474 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
38476 export function ChannelAnnouncement_set_node_signature_1(this_ptr: bigint, val: number): void {
38477 if(!isWasmInitialized) {
38478 throw new Error("initializeWasm() must be awaited first!");
38480 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
38481 // debug statements here
38483 // struct LDKECDSASignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
38485 export function ChannelAnnouncement_get_node_signature_2(this_ptr: bigint): number {
38486 if(!isWasmInitialized) {
38487 throw new Error("initializeWasm() must be awaited first!");
38489 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
38490 return nativeResponseValue;
38492 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
38494 export function ChannelAnnouncement_set_node_signature_2(this_ptr: bigint, val: number): void {
38495 if(!isWasmInitialized) {
38496 throw new Error("initializeWasm() must be awaited first!");
38498 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
38499 // debug statements here
38501 // struct LDKECDSASignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
38503 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: bigint): number {
38504 if(!isWasmInitialized) {
38505 throw new Error("initializeWasm() must be awaited first!");
38507 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
38508 return nativeResponseValue;
38510 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
38512 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: bigint, val: number): void {
38513 if(!isWasmInitialized) {
38514 throw new Error("initializeWasm() must be awaited first!");
38516 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
38517 // debug statements here
38519 // struct LDKECDSASignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
38521 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: bigint): number {
38522 if(!isWasmInitialized) {
38523 throw new Error("initializeWasm() must be awaited first!");
38525 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
38526 return nativeResponseValue;
38528 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
38530 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: bigint, val: number): void {
38531 if(!isWasmInitialized) {
38532 throw new Error("initializeWasm() must be awaited first!");
38534 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
38535 // debug statements here
38537 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
38539 export function ChannelAnnouncement_get_contents(this_ptr: bigint): bigint {
38540 if(!isWasmInitialized) {
38541 throw new Error("initializeWasm() must be awaited first!");
38543 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
38544 return nativeResponseValue;
38546 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
38548 export function ChannelAnnouncement_set_contents(this_ptr: bigint, val: bigint): void {
38549 if(!isWasmInitialized) {
38550 throw new Error("initializeWasm() must be awaited first!");
38552 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
38553 // debug statements here
38555 // 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);
38557 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 {
38558 if(!isWasmInitialized) {
38559 throw new Error("initializeWasm() must be awaited first!");
38561 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
38562 return nativeResponseValue;
38564 // uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
38566 export function ChannelAnnouncement_clone_ptr(arg: bigint): bigint {
38567 if(!isWasmInitialized) {
38568 throw new Error("initializeWasm() must be awaited first!");
38570 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
38571 return nativeResponseValue;
38573 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
38575 export function ChannelAnnouncement_clone(orig: bigint): bigint {
38576 if(!isWasmInitialized) {
38577 throw new Error("initializeWasm() must be awaited first!");
38579 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
38580 return nativeResponseValue;
38582 // uint64_t ChannelAnnouncement_hash(const struct LDKChannelAnnouncement *NONNULL_PTR o);
38584 export function ChannelAnnouncement_hash(o: bigint): bigint {
38585 if(!isWasmInitialized) {
38586 throw new Error("initializeWasm() must be awaited first!");
38588 const nativeResponseValue = wasm.TS_ChannelAnnouncement_hash(o);
38589 return nativeResponseValue;
38591 // bool ChannelAnnouncement_eq(const struct LDKChannelAnnouncement *NONNULL_PTR a, const struct LDKChannelAnnouncement *NONNULL_PTR b);
38593 export function ChannelAnnouncement_eq(a: bigint, b: bigint): boolean {
38594 if(!isWasmInitialized) {
38595 throw new Error("initializeWasm() must be awaited first!");
38597 const nativeResponseValue = wasm.TS_ChannelAnnouncement_eq(a, b);
38598 return nativeResponseValue;
38600 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
38602 export function UnsignedChannelUpdate_free(this_obj: bigint): void {
38603 if(!isWasmInitialized) {
38604 throw new Error("initializeWasm() must be awaited first!");
38606 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
38607 // debug statements here
38609 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
38611 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: bigint): number {
38612 if(!isWasmInitialized) {
38613 throw new Error("initializeWasm() must be awaited first!");
38615 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
38616 return nativeResponseValue;
38618 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
38620 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: bigint, val: number): void {
38621 if(!isWasmInitialized) {
38622 throw new Error("initializeWasm() must be awaited first!");
38624 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
38625 // debug statements here
38627 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
38629 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: bigint): bigint {
38630 if(!isWasmInitialized) {
38631 throw new Error("initializeWasm() must be awaited first!");
38633 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
38634 return nativeResponseValue;
38636 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
38638 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
38639 if(!isWasmInitialized) {
38640 throw new Error("initializeWasm() must be awaited first!");
38642 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
38643 // debug statements here
38645 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
38647 export function UnsignedChannelUpdate_get_timestamp(this_ptr: bigint): number {
38648 if(!isWasmInitialized) {
38649 throw new Error("initializeWasm() must be awaited first!");
38651 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
38652 return nativeResponseValue;
38654 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
38656 export function UnsignedChannelUpdate_set_timestamp(this_ptr: bigint, val: number): void {
38657 if(!isWasmInitialized) {
38658 throw new Error("initializeWasm() must be awaited first!");
38660 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
38661 // debug statements here
38663 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
38665 export function UnsignedChannelUpdate_get_flags(this_ptr: bigint): number {
38666 if(!isWasmInitialized) {
38667 throw new Error("initializeWasm() must be awaited first!");
38669 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
38670 return nativeResponseValue;
38672 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
38674 export function UnsignedChannelUpdate_set_flags(this_ptr: bigint, val: number): void {
38675 if(!isWasmInitialized) {
38676 throw new Error("initializeWasm() must be awaited first!");
38678 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
38679 // debug statements here
38681 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
38683 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: bigint): number {
38684 if(!isWasmInitialized) {
38685 throw new Error("initializeWasm() must be awaited first!");
38687 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
38688 return nativeResponseValue;
38690 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
38692 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
38693 if(!isWasmInitialized) {
38694 throw new Error("initializeWasm() must be awaited first!");
38696 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
38697 // debug statements here
38699 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
38701 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: bigint): bigint {
38702 if(!isWasmInitialized) {
38703 throw new Error("initializeWasm() must be awaited first!");
38705 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
38706 return nativeResponseValue;
38708 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
38710 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
38711 if(!isWasmInitialized) {
38712 throw new Error("initializeWasm() must be awaited first!");
38714 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
38715 // debug statements here
38717 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
38719 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: bigint): bigint {
38720 if(!isWasmInitialized) {
38721 throw new Error("initializeWasm() must be awaited first!");
38723 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
38724 return nativeResponseValue;
38726 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
38728 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
38729 if(!isWasmInitialized) {
38730 throw new Error("initializeWasm() must be awaited first!");
38732 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
38733 // debug statements here
38735 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
38737 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: bigint): number {
38738 if(!isWasmInitialized) {
38739 throw new Error("initializeWasm() must be awaited first!");
38741 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
38742 return nativeResponseValue;
38744 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
38746 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: bigint, val: number): void {
38747 if(!isWasmInitialized) {
38748 throw new Error("initializeWasm() must be awaited first!");
38750 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
38751 // debug statements here
38753 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
38755 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: bigint): number {
38756 if(!isWasmInitialized) {
38757 throw new Error("initializeWasm() must be awaited first!");
38759 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
38760 return nativeResponseValue;
38762 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
38764 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
38765 if(!isWasmInitialized) {
38766 throw new Error("initializeWasm() must be awaited first!");
38768 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
38769 // debug statements here
38771 // struct LDKCVec_u8Z UnsignedChannelUpdate_get_excess_data(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
38773 export function UnsignedChannelUpdate_get_excess_data(this_ptr: bigint): number {
38774 if(!isWasmInitialized) {
38775 throw new Error("initializeWasm() must be awaited first!");
38777 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_excess_data(this_ptr);
38778 return nativeResponseValue;
38780 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
38782 export function UnsignedChannelUpdate_set_excess_data(this_ptr: bigint, val: number): void {
38783 if(!isWasmInitialized) {
38784 throw new Error("initializeWasm() must be awaited first!");
38786 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
38787 // debug statements here
38789 // 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);
38791 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 {
38792 if(!isWasmInitialized) {
38793 throw new Error("initializeWasm() must be awaited first!");
38795 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);
38796 return nativeResponseValue;
38798 // uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
38800 export function UnsignedChannelUpdate_clone_ptr(arg: bigint): bigint {
38801 if(!isWasmInitialized) {
38802 throw new Error("initializeWasm() must be awaited first!");
38804 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
38805 return nativeResponseValue;
38807 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
38809 export function UnsignedChannelUpdate_clone(orig: bigint): bigint {
38810 if(!isWasmInitialized) {
38811 throw new Error("initializeWasm() must be awaited first!");
38813 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
38814 return nativeResponseValue;
38816 // uint64_t UnsignedChannelUpdate_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR o);
38818 export function UnsignedChannelUpdate_hash(o: bigint): bigint {
38819 if(!isWasmInitialized) {
38820 throw new Error("initializeWasm() must be awaited first!");
38822 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_hash(o);
38823 return nativeResponseValue;
38825 // bool UnsignedChannelUpdate_eq(const struct LDKUnsignedChannelUpdate *NONNULL_PTR a, const struct LDKUnsignedChannelUpdate *NONNULL_PTR b);
38827 export function UnsignedChannelUpdate_eq(a: bigint, b: bigint): boolean {
38828 if(!isWasmInitialized) {
38829 throw new Error("initializeWasm() must be awaited first!");
38831 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_eq(a, b);
38832 return nativeResponseValue;
38834 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
38836 export function ChannelUpdate_free(this_obj: bigint): void {
38837 if(!isWasmInitialized) {
38838 throw new Error("initializeWasm() must be awaited first!");
38840 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
38841 // debug statements here
38843 // struct LDKECDSASignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
38845 export function ChannelUpdate_get_signature(this_ptr: bigint): number {
38846 if(!isWasmInitialized) {
38847 throw new Error("initializeWasm() must be awaited first!");
38849 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
38850 return nativeResponseValue;
38852 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
38854 export function ChannelUpdate_set_signature(this_ptr: bigint, val: number): void {
38855 if(!isWasmInitialized) {
38856 throw new Error("initializeWasm() must be awaited first!");
38858 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
38859 // debug statements here
38861 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
38863 export function ChannelUpdate_get_contents(this_ptr: bigint): bigint {
38864 if(!isWasmInitialized) {
38865 throw new Error("initializeWasm() must be awaited first!");
38867 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
38868 return nativeResponseValue;
38870 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
38872 export function ChannelUpdate_set_contents(this_ptr: bigint, val: bigint): void {
38873 if(!isWasmInitialized) {
38874 throw new Error("initializeWasm() must be awaited first!");
38876 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
38877 // debug statements here
38879 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKECDSASignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
38881 export function ChannelUpdate_new(signature_arg: number, contents_arg: bigint): bigint {
38882 if(!isWasmInitialized) {
38883 throw new Error("initializeWasm() must be awaited first!");
38885 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
38886 return nativeResponseValue;
38888 // uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
38890 export function ChannelUpdate_clone_ptr(arg: bigint): bigint {
38891 if(!isWasmInitialized) {
38892 throw new Error("initializeWasm() must be awaited first!");
38894 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
38895 return nativeResponseValue;
38897 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
38899 export function ChannelUpdate_clone(orig: bigint): bigint {
38900 if(!isWasmInitialized) {
38901 throw new Error("initializeWasm() must be awaited first!");
38903 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
38904 return nativeResponseValue;
38906 // uint64_t ChannelUpdate_hash(const struct LDKChannelUpdate *NONNULL_PTR o);
38908 export function ChannelUpdate_hash(o: bigint): bigint {
38909 if(!isWasmInitialized) {
38910 throw new Error("initializeWasm() must be awaited first!");
38912 const nativeResponseValue = wasm.TS_ChannelUpdate_hash(o);
38913 return nativeResponseValue;
38915 // bool ChannelUpdate_eq(const struct LDKChannelUpdate *NONNULL_PTR a, const struct LDKChannelUpdate *NONNULL_PTR b);
38917 export function ChannelUpdate_eq(a: bigint, b: bigint): boolean {
38918 if(!isWasmInitialized) {
38919 throw new Error("initializeWasm() must be awaited first!");
38921 const nativeResponseValue = wasm.TS_ChannelUpdate_eq(a, b);
38922 return nativeResponseValue;
38924 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
38926 export function QueryChannelRange_free(this_obj: bigint): void {
38927 if(!isWasmInitialized) {
38928 throw new Error("initializeWasm() must be awaited first!");
38930 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
38931 // debug statements here
38933 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
38935 export function QueryChannelRange_get_chain_hash(this_ptr: bigint): number {
38936 if(!isWasmInitialized) {
38937 throw new Error("initializeWasm() must be awaited first!");
38939 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
38940 return nativeResponseValue;
38942 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
38944 export function QueryChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
38945 if(!isWasmInitialized) {
38946 throw new Error("initializeWasm() must be awaited first!");
38948 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
38949 // debug statements here
38951 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
38953 export function QueryChannelRange_get_first_blocknum(this_ptr: bigint): number {
38954 if(!isWasmInitialized) {
38955 throw new Error("initializeWasm() must be awaited first!");
38957 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
38958 return nativeResponseValue;
38960 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
38962 export function QueryChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
38963 if(!isWasmInitialized) {
38964 throw new Error("initializeWasm() must be awaited first!");
38966 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
38967 // debug statements here
38969 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
38971 export function QueryChannelRange_get_number_of_blocks(this_ptr: bigint): number {
38972 if(!isWasmInitialized) {
38973 throw new Error("initializeWasm() must be awaited first!");
38975 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
38976 return nativeResponseValue;
38978 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
38980 export function QueryChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
38981 if(!isWasmInitialized) {
38982 throw new Error("initializeWasm() must be awaited first!");
38984 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
38985 // debug statements here
38987 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
38989 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): bigint {
38990 if(!isWasmInitialized) {
38991 throw new Error("initializeWasm() must be awaited first!");
38993 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
38994 return nativeResponseValue;
38996 // uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
38998 export function QueryChannelRange_clone_ptr(arg: bigint): bigint {
38999 if(!isWasmInitialized) {
39000 throw new Error("initializeWasm() must be awaited first!");
39002 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
39003 return nativeResponseValue;
39005 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
39007 export function QueryChannelRange_clone(orig: bigint): bigint {
39008 if(!isWasmInitialized) {
39009 throw new Error("initializeWasm() must be awaited first!");
39011 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
39012 return nativeResponseValue;
39014 // uint64_t QueryChannelRange_hash(const struct LDKQueryChannelRange *NONNULL_PTR o);
39016 export function QueryChannelRange_hash(o: bigint): bigint {
39017 if(!isWasmInitialized) {
39018 throw new Error("initializeWasm() must be awaited first!");
39020 const nativeResponseValue = wasm.TS_QueryChannelRange_hash(o);
39021 return nativeResponseValue;
39023 // bool QueryChannelRange_eq(const struct LDKQueryChannelRange *NONNULL_PTR a, const struct LDKQueryChannelRange *NONNULL_PTR b);
39025 export function QueryChannelRange_eq(a: bigint, b: bigint): boolean {
39026 if(!isWasmInitialized) {
39027 throw new Error("initializeWasm() must be awaited first!");
39029 const nativeResponseValue = wasm.TS_QueryChannelRange_eq(a, b);
39030 return nativeResponseValue;
39032 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
39034 export function ReplyChannelRange_free(this_obj: bigint): void {
39035 if(!isWasmInitialized) {
39036 throw new Error("initializeWasm() must be awaited first!");
39038 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
39039 // debug statements here
39041 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
39043 export function ReplyChannelRange_get_chain_hash(this_ptr: bigint): number {
39044 if(!isWasmInitialized) {
39045 throw new Error("initializeWasm() must be awaited first!");
39047 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
39048 return nativeResponseValue;
39050 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
39052 export function ReplyChannelRange_set_chain_hash(this_ptr: bigint, val: number): void {
39053 if(!isWasmInitialized) {
39054 throw new Error("initializeWasm() must be awaited first!");
39056 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
39057 // debug statements here
39059 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
39061 export function ReplyChannelRange_get_first_blocknum(this_ptr: bigint): number {
39062 if(!isWasmInitialized) {
39063 throw new Error("initializeWasm() must be awaited first!");
39065 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
39066 return nativeResponseValue;
39068 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
39070 export function ReplyChannelRange_set_first_blocknum(this_ptr: bigint, val: number): void {
39071 if(!isWasmInitialized) {
39072 throw new Error("initializeWasm() must be awaited first!");
39074 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
39075 // debug statements here
39077 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
39079 export function ReplyChannelRange_get_number_of_blocks(this_ptr: bigint): number {
39080 if(!isWasmInitialized) {
39081 throw new Error("initializeWasm() must be awaited first!");
39083 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
39084 return nativeResponseValue;
39086 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
39088 export function ReplyChannelRange_set_number_of_blocks(this_ptr: bigint, val: number): void {
39089 if(!isWasmInitialized) {
39090 throw new Error("initializeWasm() must be awaited first!");
39092 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
39093 // debug statements here
39095 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
39097 export function ReplyChannelRange_get_sync_complete(this_ptr: bigint): boolean {
39098 if(!isWasmInitialized) {
39099 throw new Error("initializeWasm() must be awaited first!");
39101 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
39102 return nativeResponseValue;
39104 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
39106 export function ReplyChannelRange_set_sync_complete(this_ptr: bigint, val: boolean): void {
39107 if(!isWasmInitialized) {
39108 throw new Error("initializeWasm() must be awaited first!");
39110 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
39111 // debug statements here
39113 // struct LDKCVec_u64Z ReplyChannelRange_get_short_channel_ids(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
39115 export function ReplyChannelRange_get_short_channel_ids(this_ptr: bigint): number {
39116 if(!isWasmInitialized) {
39117 throw new Error("initializeWasm() must be awaited first!");
39119 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_short_channel_ids(this_ptr);
39120 return nativeResponseValue;
39122 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
39124 export function ReplyChannelRange_set_short_channel_ids(this_ptr: bigint, val: number): void {
39125 if(!isWasmInitialized) {
39126 throw new Error("initializeWasm() must be awaited first!");
39128 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
39129 // debug statements here
39131 // 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);
39133 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 {
39134 if(!isWasmInitialized) {
39135 throw new Error("initializeWasm() must be awaited first!");
39137 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
39138 return nativeResponseValue;
39140 // uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
39142 export function ReplyChannelRange_clone_ptr(arg: bigint): bigint {
39143 if(!isWasmInitialized) {
39144 throw new Error("initializeWasm() must be awaited first!");
39146 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
39147 return nativeResponseValue;
39149 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
39151 export function ReplyChannelRange_clone(orig: bigint): bigint {
39152 if(!isWasmInitialized) {
39153 throw new Error("initializeWasm() must be awaited first!");
39155 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
39156 return nativeResponseValue;
39158 // uint64_t ReplyChannelRange_hash(const struct LDKReplyChannelRange *NONNULL_PTR o);
39160 export function ReplyChannelRange_hash(o: bigint): bigint {
39161 if(!isWasmInitialized) {
39162 throw new Error("initializeWasm() must be awaited first!");
39164 const nativeResponseValue = wasm.TS_ReplyChannelRange_hash(o);
39165 return nativeResponseValue;
39167 // bool ReplyChannelRange_eq(const struct LDKReplyChannelRange *NONNULL_PTR a, const struct LDKReplyChannelRange *NONNULL_PTR b);
39169 export function ReplyChannelRange_eq(a: bigint, b: bigint): boolean {
39170 if(!isWasmInitialized) {
39171 throw new Error("initializeWasm() must be awaited first!");
39173 const nativeResponseValue = wasm.TS_ReplyChannelRange_eq(a, b);
39174 return nativeResponseValue;
39176 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
39178 export function QueryShortChannelIds_free(this_obj: bigint): void {
39179 if(!isWasmInitialized) {
39180 throw new Error("initializeWasm() must be awaited first!");
39182 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
39183 // debug statements here
39185 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
39187 export function QueryShortChannelIds_get_chain_hash(this_ptr: bigint): number {
39188 if(!isWasmInitialized) {
39189 throw new Error("initializeWasm() must be awaited first!");
39191 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
39192 return nativeResponseValue;
39194 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
39196 export function QueryShortChannelIds_set_chain_hash(this_ptr: bigint, val: number): void {
39197 if(!isWasmInitialized) {
39198 throw new Error("initializeWasm() must be awaited first!");
39200 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
39201 // debug statements here
39203 // struct LDKCVec_u64Z QueryShortChannelIds_get_short_channel_ids(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr);
39205 export function QueryShortChannelIds_get_short_channel_ids(this_ptr: bigint): number {
39206 if(!isWasmInitialized) {
39207 throw new Error("initializeWasm() must be awaited first!");
39209 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_short_channel_ids(this_ptr);
39210 return nativeResponseValue;
39212 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
39214 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: bigint, val: number): void {
39215 if(!isWasmInitialized) {
39216 throw new Error("initializeWasm() must be awaited first!");
39218 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
39219 // debug statements here
39221 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
39223 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): bigint {
39224 if(!isWasmInitialized) {
39225 throw new Error("initializeWasm() must be awaited first!");
39227 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
39228 return nativeResponseValue;
39230 // uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
39232 export function QueryShortChannelIds_clone_ptr(arg: bigint): bigint {
39233 if(!isWasmInitialized) {
39234 throw new Error("initializeWasm() must be awaited first!");
39236 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
39237 return nativeResponseValue;
39239 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
39241 export function QueryShortChannelIds_clone(orig: bigint): bigint {
39242 if(!isWasmInitialized) {
39243 throw new Error("initializeWasm() must be awaited first!");
39245 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
39246 return nativeResponseValue;
39248 // uint64_t QueryShortChannelIds_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR o);
39250 export function QueryShortChannelIds_hash(o: bigint): bigint {
39251 if(!isWasmInitialized) {
39252 throw new Error("initializeWasm() must be awaited first!");
39254 const nativeResponseValue = wasm.TS_QueryShortChannelIds_hash(o);
39255 return nativeResponseValue;
39257 // bool QueryShortChannelIds_eq(const struct LDKQueryShortChannelIds *NONNULL_PTR a, const struct LDKQueryShortChannelIds *NONNULL_PTR b);
39259 export function QueryShortChannelIds_eq(a: bigint, b: bigint): boolean {
39260 if(!isWasmInitialized) {
39261 throw new Error("initializeWasm() must be awaited first!");
39263 const nativeResponseValue = wasm.TS_QueryShortChannelIds_eq(a, b);
39264 return nativeResponseValue;
39266 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
39268 export function ReplyShortChannelIdsEnd_free(this_obj: bigint): void {
39269 if(!isWasmInitialized) {
39270 throw new Error("initializeWasm() must be awaited first!");
39272 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
39273 // debug statements here
39275 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
39277 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: bigint): number {
39278 if(!isWasmInitialized) {
39279 throw new Error("initializeWasm() must be awaited first!");
39281 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
39282 return nativeResponseValue;
39284 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
39286 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: bigint, val: number): void {
39287 if(!isWasmInitialized) {
39288 throw new Error("initializeWasm() must be awaited first!");
39290 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
39291 // debug statements here
39293 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
39295 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: bigint): boolean {
39296 if(!isWasmInitialized) {
39297 throw new Error("initializeWasm() must be awaited first!");
39299 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
39300 return nativeResponseValue;
39302 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
39304 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: bigint, val: boolean): void {
39305 if(!isWasmInitialized) {
39306 throw new Error("initializeWasm() must be awaited first!");
39308 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
39309 // debug statements here
39311 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
39313 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): bigint {
39314 if(!isWasmInitialized) {
39315 throw new Error("initializeWasm() must be awaited first!");
39317 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
39318 return nativeResponseValue;
39320 // uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
39322 export function ReplyShortChannelIdsEnd_clone_ptr(arg: bigint): bigint {
39323 if(!isWasmInitialized) {
39324 throw new Error("initializeWasm() must be awaited first!");
39326 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
39327 return nativeResponseValue;
39329 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
39331 export function ReplyShortChannelIdsEnd_clone(orig: bigint): bigint {
39332 if(!isWasmInitialized) {
39333 throw new Error("initializeWasm() must be awaited first!");
39335 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
39336 return nativeResponseValue;
39338 // uint64_t ReplyShortChannelIdsEnd_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR o);
39340 export function ReplyShortChannelIdsEnd_hash(o: bigint): bigint {
39341 if(!isWasmInitialized) {
39342 throw new Error("initializeWasm() must be awaited first!");
39344 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_hash(o);
39345 return nativeResponseValue;
39347 // bool ReplyShortChannelIdsEnd_eq(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR a, const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR b);
39349 export function ReplyShortChannelIdsEnd_eq(a: bigint, b: bigint): boolean {
39350 if(!isWasmInitialized) {
39351 throw new Error("initializeWasm() must be awaited first!");
39353 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_eq(a, b);
39354 return nativeResponseValue;
39356 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
39358 export function GossipTimestampFilter_free(this_obj: bigint): void {
39359 if(!isWasmInitialized) {
39360 throw new Error("initializeWasm() must be awaited first!");
39362 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
39363 // debug statements here
39365 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
39367 export function GossipTimestampFilter_get_chain_hash(this_ptr: bigint): number {
39368 if(!isWasmInitialized) {
39369 throw new Error("initializeWasm() must be awaited first!");
39371 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
39372 return nativeResponseValue;
39374 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
39376 export function GossipTimestampFilter_set_chain_hash(this_ptr: bigint, val: number): void {
39377 if(!isWasmInitialized) {
39378 throw new Error("initializeWasm() must be awaited first!");
39380 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
39381 // debug statements here
39383 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
39385 export function GossipTimestampFilter_get_first_timestamp(this_ptr: bigint): number {
39386 if(!isWasmInitialized) {
39387 throw new Error("initializeWasm() must be awaited first!");
39389 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
39390 return nativeResponseValue;
39392 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
39394 export function GossipTimestampFilter_set_first_timestamp(this_ptr: bigint, val: number): void {
39395 if(!isWasmInitialized) {
39396 throw new Error("initializeWasm() must be awaited first!");
39398 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
39399 // debug statements here
39401 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
39403 export function GossipTimestampFilter_get_timestamp_range(this_ptr: bigint): number {
39404 if(!isWasmInitialized) {
39405 throw new Error("initializeWasm() must be awaited first!");
39407 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
39408 return nativeResponseValue;
39410 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
39412 export function GossipTimestampFilter_set_timestamp_range(this_ptr: bigint, val: number): void {
39413 if(!isWasmInitialized) {
39414 throw new Error("initializeWasm() must be awaited first!");
39416 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
39417 // debug statements here
39419 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
39421 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): bigint {
39422 if(!isWasmInitialized) {
39423 throw new Error("initializeWasm() must be awaited first!");
39425 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
39426 return nativeResponseValue;
39428 // uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
39430 export function GossipTimestampFilter_clone_ptr(arg: bigint): bigint {
39431 if(!isWasmInitialized) {
39432 throw new Error("initializeWasm() must be awaited first!");
39434 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
39435 return nativeResponseValue;
39437 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
39439 export function GossipTimestampFilter_clone(orig: bigint): bigint {
39440 if(!isWasmInitialized) {
39441 throw new Error("initializeWasm() must be awaited first!");
39443 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
39444 return nativeResponseValue;
39446 // uint64_t GossipTimestampFilter_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR o);
39448 export function GossipTimestampFilter_hash(o: bigint): bigint {
39449 if(!isWasmInitialized) {
39450 throw new Error("initializeWasm() must be awaited first!");
39452 const nativeResponseValue = wasm.TS_GossipTimestampFilter_hash(o);
39453 return nativeResponseValue;
39455 // bool GossipTimestampFilter_eq(const struct LDKGossipTimestampFilter *NONNULL_PTR a, const struct LDKGossipTimestampFilter *NONNULL_PTR b);
39457 export function GossipTimestampFilter_eq(a: bigint, b: bigint): boolean {
39458 if(!isWasmInitialized) {
39459 throw new Error("initializeWasm() must be awaited first!");
39461 const nativeResponseValue = wasm.TS_GossipTimestampFilter_eq(a, b);
39462 return nativeResponseValue;
39464 // void ErrorAction_free(struct LDKErrorAction this_ptr);
39466 export function ErrorAction_free(this_ptr: bigint): void {
39467 if(!isWasmInitialized) {
39468 throw new Error("initializeWasm() must be awaited first!");
39470 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
39471 // debug statements here
39473 // uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
39475 export function ErrorAction_clone_ptr(arg: bigint): bigint {
39476 if(!isWasmInitialized) {
39477 throw new Error("initializeWasm() must be awaited first!");
39479 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
39480 return nativeResponseValue;
39482 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
39484 export function ErrorAction_clone(orig: bigint): bigint {
39485 if(!isWasmInitialized) {
39486 throw new Error("initializeWasm() must be awaited first!");
39488 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
39489 return nativeResponseValue;
39491 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
39493 export function ErrorAction_disconnect_peer(msg: bigint): bigint {
39494 if(!isWasmInitialized) {
39495 throw new Error("initializeWasm() must be awaited first!");
39497 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
39498 return nativeResponseValue;
39500 // struct LDKErrorAction ErrorAction_disconnect_peer_with_warning(struct LDKWarningMessage msg);
39502 export function ErrorAction_disconnect_peer_with_warning(msg: bigint): bigint {
39503 if(!isWasmInitialized) {
39504 throw new Error("initializeWasm() must be awaited first!");
39506 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer_with_warning(msg);
39507 return nativeResponseValue;
39509 // struct LDKErrorAction ErrorAction_ignore_error(void);
39511 export function ErrorAction_ignore_error(): bigint {
39512 if(!isWasmInitialized) {
39513 throw new Error("initializeWasm() must be awaited first!");
39515 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
39516 return nativeResponseValue;
39518 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
39520 export function ErrorAction_ignore_and_log(a: Level): bigint {
39521 if(!isWasmInitialized) {
39522 throw new Error("initializeWasm() must be awaited first!");
39524 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
39525 return nativeResponseValue;
39527 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
39529 export function ErrorAction_ignore_duplicate_gossip(): bigint {
39530 if(!isWasmInitialized) {
39531 throw new Error("initializeWasm() must be awaited first!");
39533 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
39534 return nativeResponseValue;
39536 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
39538 export function ErrorAction_send_error_message(msg: bigint): bigint {
39539 if(!isWasmInitialized) {
39540 throw new Error("initializeWasm() must be awaited first!");
39542 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
39543 return nativeResponseValue;
39545 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
39547 export function ErrorAction_send_warning_message(msg: bigint, log_level: Level): bigint {
39548 if(!isWasmInitialized) {
39549 throw new Error("initializeWasm() must be awaited first!");
39551 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
39552 return nativeResponseValue;
39554 // uint64_t ErrorAction_hash(const struct LDKErrorAction *NONNULL_PTR o);
39556 export function ErrorAction_hash(o: bigint): bigint {
39557 if(!isWasmInitialized) {
39558 throw new Error("initializeWasm() must be awaited first!");
39560 const nativeResponseValue = wasm.TS_ErrorAction_hash(o);
39561 return nativeResponseValue;
39563 // void LightningError_free(struct LDKLightningError this_obj);
39565 export function LightningError_free(this_obj: bigint): void {
39566 if(!isWasmInitialized) {
39567 throw new Error("initializeWasm() must be awaited first!");
39569 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
39570 // debug statements here
39572 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
39574 export function LightningError_get_err(this_ptr: bigint): number {
39575 if(!isWasmInitialized) {
39576 throw new Error("initializeWasm() must be awaited first!");
39578 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
39579 return nativeResponseValue;
39581 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
39583 export function LightningError_set_err(this_ptr: bigint, val: number): void {
39584 if(!isWasmInitialized) {
39585 throw new Error("initializeWasm() must be awaited first!");
39587 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
39588 // debug statements here
39590 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
39592 export function LightningError_get_action(this_ptr: bigint): bigint {
39593 if(!isWasmInitialized) {
39594 throw new Error("initializeWasm() must be awaited first!");
39596 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
39597 return nativeResponseValue;
39599 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
39601 export function LightningError_set_action(this_ptr: bigint, val: bigint): void {
39602 if(!isWasmInitialized) {
39603 throw new Error("initializeWasm() must be awaited first!");
39605 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
39606 // debug statements here
39608 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
39610 export function LightningError_new(err_arg: number, action_arg: bigint): bigint {
39611 if(!isWasmInitialized) {
39612 throw new Error("initializeWasm() must be awaited first!");
39614 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
39615 return nativeResponseValue;
39617 // uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
39619 export function LightningError_clone_ptr(arg: bigint): bigint {
39620 if(!isWasmInitialized) {
39621 throw new Error("initializeWasm() must be awaited first!");
39623 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
39624 return nativeResponseValue;
39626 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
39628 export function LightningError_clone(orig: bigint): bigint {
39629 if(!isWasmInitialized) {
39630 throw new Error("initializeWasm() must be awaited first!");
39632 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
39633 return nativeResponseValue;
39635 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
39637 export function CommitmentUpdate_free(this_obj: bigint): void {
39638 if(!isWasmInitialized) {
39639 throw new Error("initializeWasm() must be awaited first!");
39641 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
39642 // debug statements here
39644 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
39646 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: bigint): number {
39647 if(!isWasmInitialized) {
39648 throw new Error("initializeWasm() must be awaited first!");
39650 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
39651 return nativeResponseValue;
39653 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
39655 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: bigint, val: number): void {
39656 if(!isWasmInitialized) {
39657 throw new Error("initializeWasm() must be awaited first!");
39659 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
39660 // debug statements here
39662 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
39664 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: bigint): number {
39665 if(!isWasmInitialized) {
39666 throw new Error("initializeWasm() must be awaited first!");
39668 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
39669 return nativeResponseValue;
39671 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
39673 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: bigint, val: number): void {
39674 if(!isWasmInitialized) {
39675 throw new Error("initializeWasm() must be awaited first!");
39677 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
39678 // debug statements here
39680 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
39682 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: bigint): number {
39683 if(!isWasmInitialized) {
39684 throw new Error("initializeWasm() must be awaited first!");
39686 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
39687 return nativeResponseValue;
39689 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
39691 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: bigint, val: number): void {
39692 if(!isWasmInitialized) {
39693 throw new Error("initializeWasm() must be awaited first!");
39695 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
39696 // debug statements here
39698 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
39700 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: bigint): number {
39701 if(!isWasmInitialized) {
39702 throw new Error("initializeWasm() must be awaited first!");
39704 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
39705 return nativeResponseValue;
39707 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
39709 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: bigint, val: number): void {
39710 if(!isWasmInitialized) {
39711 throw new Error("initializeWasm() must be awaited first!");
39713 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
39714 // debug statements here
39716 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
39718 export function CommitmentUpdate_get_update_fee(this_ptr: bigint): bigint {
39719 if(!isWasmInitialized) {
39720 throw new Error("initializeWasm() must be awaited first!");
39722 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
39723 return nativeResponseValue;
39725 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
39727 export function CommitmentUpdate_set_update_fee(this_ptr: bigint, val: bigint): void {
39728 if(!isWasmInitialized) {
39729 throw new Error("initializeWasm() must be awaited first!");
39731 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
39732 // debug statements here
39734 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
39736 export function CommitmentUpdate_get_commitment_signed(this_ptr: bigint): bigint {
39737 if(!isWasmInitialized) {
39738 throw new Error("initializeWasm() must be awaited first!");
39740 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
39741 return nativeResponseValue;
39743 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
39745 export function CommitmentUpdate_set_commitment_signed(this_ptr: bigint, val: bigint): void {
39746 if(!isWasmInitialized) {
39747 throw new Error("initializeWasm() must be awaited first!");
39749 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
39750 // debug statements here
39752 // 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);
39754 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 {
39755 if(!isWasmInitialized) {
39756 throw new Error("initializeWasm() must be awaited first!");
39758 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);
39759 return nativeResponseValue;
39761 // uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
39763 export function CommitmentUpdate_clone_ptr(arg: bigint): bigint {
39764 if(!isWasmInitialized) {
39765 throw new Error("initializeWasm() must be awaited first!");
39767 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
39768 return nativeResponseValue;
39770 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
39772 export function CommitmentUpdate_clone(orig: bigint): bigint {
39773 if(!isWasmInitialized) {
39774 throw new Error("initializeWasm() must be awaited first!");
39776 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
39777 return nativeResponseValue;
39779 // uint64_t CommitmentUpdate_hash(const struct LDKCommitmentUpdate *NONNULL_PTR o);
39781 export function CommitmentUpdate_hash(o: bigint): bigint {
39782 if(!isWasmInitialized) {
39783 throw new Error("initializeWasm() must be awaited first!");
39785 const nativeResponseValue = wasm.TS_CommitmentUpdate_hash(o);
39786 return nativeResponseValue;
39788 // bool CommitmentUpdate_eq(const struct LDKCommitmentUpdate *NONNULL_PTR a, const struct LDKCommitmentUpdate *NONNULL_PTR b);
39790 export function CommitmentUpdate_eq(a: bigint, b: bigint): boolean {
39791 if(!isWasmInitialized) {
39792 throw new Error("initializeWasm() must be awaited first!");
39794 const nativeResponseValue = wasm.TS_CommitmentUpdate_eq(a, b);
39795 return nativeResponseValue;
39797 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
39799 export function ChannelMessageHandler_free(this_ptr: bigint): void {
39800 if(!isWasmInitialized) {
39801 throw new Error("initializeWasm() must be awaited first!");
39803 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
39804 // debug statements here
39806 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
39808 export function RoutingMessageHandler_free(this_ptr: bigint): void {
39809 if(!isWasmInitialized) {
39810 throw new Error("initializeWasm() must be awaited first!");
39812 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
39813 // debug statements here
39815 // void OnionMessageHandler_free(struct LDKOnionMessageHandler this_ptr);
39817 export function OnionMessageHandler_free(this_ptr: bigint): void {
39818 if(!isWasmInitialized) {
39819 throw new Error("initializeWasm() must be awaited first!");
39821 const nativeResponseValue = wasm.TS_OnionMessageHandler_free(this_ptr);
39822 // debug statements here
39824 // void FinalOnionHopData_free(struct LDKFinalOnionHopData this_obj);
39826 export function FinalOnionHopData_free(this_obj: bigint): void {
39827 if(!isWasmInitialized) {
39828 throw new Error("initializeWasm() must be awaited first!");
39830 const nativeResponseValue = wasm.TS_FinalOnionHopData_free(this_obj);
39831 // debug statements here
39833 // const uint8_t (*FinalOnionHopData_get_payment_secret(const struct LDKFinalOnionHopData *NONNULL_PTR this_ptr))[32];
39835 export function FinalOnionHopData_get_payment_secret(this_ptr: bigint): number {
39836 if(!isWasmInitialized) {
39837 throw new Error("initializeWasm() must be awaited first!");
39839 const nativeResponseValue = wasm.TS_FinalOnionHopData_get_payment_secret(this_ptr);
39840 return nativeResponseValue;
39842 // void FinalOnionHopData_set_payment_secret(struct LDKFinalOnionHopData *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
39844 export function FinalOnionHopData_set_payment_secret(this_ptr: bigint, val: number): void {
39845 if(!isWasmInitialized) {
39846 throw new Error("initializeWasm() must be awaited first!");
39848 const nativeResponseValue = wasm.TS_FinalOnionHopData_set_payment_secret(this_ptr, val);
39849 // debug statements here
39851 // uint64_t FinalOnionHopData_get_total_msat(const struct LDKFinalOnionHopData *NONNULL_PTR this_ptr);
39853 export function FinalOnionHopData_get_total_msat(this_ptr: bigint): bigint {
39854 if(!isWasmInitialized) {
39855 throw new Error("initializeWasm() must be awaited first!");
39857 const nativeResponseValue = wasm.TS_FinalOnionHopData_get_total_msat(this_ptr);
39858 return nativeResponseValue;
39860 // void FinalOnionHopData_set_total_msat(struct LDKFinalOnionHopData *NONNULL_PTR this_ptr, uint64_t val);
39862 export function FinalOnionHopData_set_total_msat(this_ptr: bigint, val: bigint): void {
39863 if(!isWasmInitialized) {
39864 throw new Error("initializeWasm() must be awaited first!");
39866 const nativeResponseValue = wasm.TS_FinalOnionHopData_set_total_msat(this_ptr, val);
39867 // debug statements here
39869 // MUST_USE_RES struct LDKFinalOnionHopData FinalOnionHopData_new(struct LDKThirtyTwoBytes payment_secret_arg, uint64_t total_msat_arg);
39871 export function FinalOnionHopData_new(payment_secret_arg: number, total_msat_arg: bigint): bigint {
39872 if(!isWasmInitialized) {
39873 throw new Error("initializeWasm() must be awaited first!");
39875 const nativeResponseValue = wasm.TS_FinalOnionHopData_new(payment_secret_arg, total_msat_arg);
39876 return nativeResponseValue;
39878 // uint64_t FinalOnionHopData_clone_ptr(LDKFinalOnionHopData *NONNULL_PTR arg);
39880 export function FinalOnionHopData_clone_ptr(arg: bigint): bigint {
39881 if(!isWasmInitialized) {
39882 throw new Error("initializeWasm() must be awaited first!");
39884 const nativeResponseValue = wasm.TS_FinalOnionHopData_clone_ptr(arg);
39885 return nativeResponseValue;
39887 // struct LDKFinalOnionHopData FinalOnionHopData_clone(const struct LDKFinalOnionHopData *NONNULL_PTR orig);
39889 export function FinalOnionHopData_clone(orig: bigint): bigint {
39890 if(!isWasmInitialized) {
39891 throw new Error("initializeWasm() must be awaited first!");
39893 const nativeResponseValue = wasm.TS_FinalOnionHopData_clone(orig);
39894 return nativeResponseValue;
39896 // void OnionPacket_free(struct LDKOnionPacket this_obj);
39898 export function OnionPacket_free(this_obj: bigint): void {
39899 if(!isWasmInitialized) {
39900 throw new Error("initializeWasm() must be awaited first!");
39902 const nativeResponseValue = wasm.TS_OnionPacket_free(this_obj);
39903 // debug statements here
39905 // uint8_t OnionPacket_get_version(const struct LDKOnionPacket *NONNULL_PTR this_ptr);
39907 export function OnionPacket_get_version(this_ptr: bigint): number {
39908 if(!isWasmInitialized) {
39909 throw new Error("initializeWasm() must be awaited first!");
39911 const nativeResponseValue = wasm.TS_OnionPacket_get_version(this_ptr);
39912 return nativeResponseValue;
39914 // void OnionPacket_set_version(struct LDKOnionPacket *NONNULL_PTR this_ptr, uint8_t val);
39916 export function OnionPacket_set_version(this_ptr: bigint, val: number): void {
39917 if(!isWasmInitialized) {
39918 throw new Error("initializeWasm() must be awaited first!");
39920 const nativeResponseValue = wasm.TS_OnionPacket_set_version(this_ptr, val);
39921 // debug statements here
39923 // struct LDKCResult_PublicKeySecp256k1ErrorZ OnionPacket_get_public_key(const struct LDKOnionPacket *NONNULL_PTR this_ptr);
39925 export function OnionPacket_get_public_key(this_ptr: bigint): bigint {
39926 if(!isWasmInitialized) {
39927 throw new Error("initializeWasm() must be awaited first!");
39929 const nativeResponseValue = wasm.TS_OnionPacket_get_public_key(this_ptr);
39930 return nativeResponseValue;
39932 // void OnionPacket_set_public_key(struct LDKOnionPacket *NONNULL_PTR this_ptr, struct LDKCResult_PublicKeySecp256k1ErrorZ val);
39934 export function OnionPacket_set_public_key(this_ptr: bigint, val: bigint): void {
39935 if(!isWasmInitialized) {
39936 throw new Error("initializeWasm() must be awaited first!");
39938 const nativeResponseValue = wasm.TS_OnionPacket_set_public_key(this_ptr, val);
39939 // debug statements here
39941 // const uint8_t (*OnionPacket_get_hmac(const struct LDKOnionPacket *NONNULL_PTR this_ptr))[32];
39943 export function OnionPacket_get_hmac(this_ptr: bigint): number {
39944 if(!isWasmInitialized) {
39945 throw new Error("initializeWasm() must be awaited first!");
39947 const nativeResponseValue = wasm.TS_OnionPacket_get_hmac(this_ptr);
39948 return nativeResponseValue;
39950 // void OnionPacket_set_hmac(struct LDKOnionPacket *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
39952 export function OnionPacket_set_hmac(this_ptr: bigint, val: number): void {
39953 if(!isWasmInitialized) {
39954 throw new Error("initializeWasm() must be awaited first!");
39956 const nativeResponseValue = wasm.TS_OnionPacket_set_hmac(this_ptr, val);
39957 // debug statements here
39959 // uint64_t OnionPacket_clone_ptr(LDKOnionPacket *NONNULL_PTR arg);
39961 export function OnionPacket_clone_ptr(arg: bigint): bigint {
39962 if(!isWasmInitialized) {
39963 throw new Error("initializeWasm() must be awaited first!");
39965 const nativeResponseValue = wasm.TS_OnionPacket_clone_ptr(arg);
39966 return nativeResponseValue;
39968 // struct LDKOnionPacket OnionPacket_clone(const struct LDKOnionPacket *NONNULL_PTR orig);
39970 export function OnionPacket_clone(orig: bigint): bigint {
39971 if(!isWasmInitialized) {
39972 throw new Error("initializeWasm() must be awaited first!");
39974 const nativeResponseValue = wasm.TS_OnionPacket_clone(orig);
39975 return nativeResponseValue;
39977 // uint64_t OnionPacket_hash(const struct LDKOnionPacket *NONNULL_PTR o);
39979 export function OnionPacket_hash(o: bigint): bigint {
39980 if(!isWasmInitialized) {
39981 throw new Error("initializeWasm() must be awaited first!");
39983 const nativeResponseValue = wasm.TS_OnionPacket_hash(o);
39984 return nativeResponseValue;
39986 // bool OnionPacket_eq(const struct LDKOnionPacket *NONNULL_PTR a, const struct LDKOnionPacket *NONNULL_PTR b);
39988 export function OnionPacket_eq(a: bigint, b: bigint): boolean {
39989 if(!isWasmInitialized) {
39990 throw new Error("initializeWasm() must be awaited first!");
39992 const nativeResponseValue = wasm.TS_OnionPacket_eq(a, b);
39993 return nativeResponseValue;
39995 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
39997 export function AcceptChannel_write(obj: bigint): number {
39998 if(!isWasmInitialized) {
39999 throw new Error("initializeWasm() must be awaited first!");
40001 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
40002 return nativeResponseValue;
40004 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
40006 export function AcceptChannel_read(ser: number): bigint {
40007 if(!isWasmInitialized) {
40008 throw new Error("initializeWasm() must be awaited first!");
40010 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
40011 return nativeResponseValue;
40013 // struct LDKCVec_u8Z AcceptChannelV2_write(const struct LDKAcceptChannelV2 *NONNULL_PTR obj);
40015 export function AcceptChannelV2_write(obj: bigint): number {
40016 if(!isWasmInitialized) {
40017 throw new Error("initializeWasm() must be awaited first!");
40019 const nativeResponseValue = wasm.TS_AcceptChannelV2_write(obj);
40020 return nativeResponseValue;
40022 // struct LDKCResult_AcceptChannelV2DecodeErrorZ AcceptChannelV2_read(struct LDKu8slice ser);
40024 export function AcceptChannelV2_read(ser: number): bigint {
40025 if(!isWasmInitialized) {
40026 throw new Error("initializeWasm() must be awaited first!");
40028 const nativeResponseValue = wasm.TS_AcceptChannelV2_read(ser);
40029 return nativeResponseValue;
40031 // struct LDKCVec_u8Z Stfu_write(const struct LDKStfu *NONNULL_PTR obj);
40033 export function Stfu_write(obj: bigint): number {
40034 if(!isWasmInitialized) {
40035 throw new Error("initializeWasm() must be awaited first!");
40037 const nativeResponseValue = wasm.TS_Stfu_write(obj);
40038 return nativeResponseValue;
40040 // struct LDKCResult_StfuDecodeErrorZ Stfu_read(struct LDKu8slice ser);
40042 export function Stfu_read(ser: number): bigint {
40043 if(!isWasmInitialized) {
40044 throw new Error("initializeWasm() must be awaited first!");
40046 const nativeResponseValue = wasm.TS_Stfu_read(ser);
40047 return nativeResponseValue;
40049 // struct LDKCVec_u8Z Splice_write(const struct LDKSplice *NONNULL_PTR obj);
40051 export function Splice_write(obj: bigint): number {
40052 if(!isWasmInitialized) {
40053 throw new Error("initializeWasm() must be awaited first!");
40055 const nativeResponseValue = wasm.TS_Splice_write(obj);
40056 return nativeResponseValue;
40058 // struct LDKCResult_SpliceDecodeErrorZ Splice_read(struct LDKu8slice ser);
40060 export function Splice_read(ser: number): bigint {
40061 if(!isWasmInitialized) {
40062 throw new Error("initializeWasm() must be awaited first!");
40064 const nativeResponseValue = wasm.TS_Splice_read(ser);
40065 return nativeResponseValue;
40067 // struct LDKCVec_u8Z SpliceAck_write(const struct LDKSpliceAck *NONNULL_PTR obj);
40069 export function SpliceAck_write(obj: bigint): number {
40070 if(!isWasmInitialized) {
40071 throw new Error("initializeWasm() must be awaited first!");
40073 const nativeResponseValue = wasm.TS_SpliceAck_write(obj);
40074 return nativeResponseValue;
40076 // struct LDKCResult_SpliceAckDecodeErrorZ SpliceAck_read(struct LDKu8slice ser);
40078 export function SpliceAck_read(ser: number): bigint {
40079 if(!isWasmInitialized) {
40080 throw new Error("initializeWasm() must be awaited first!");
40082 const nativeResponseValue = wasm.TS_SpliceAck_read(ser);
40083 return nativeResponseValue;
40085 // struct LDKCVec_u8Z SpliceLocked_write(const struct LDKSpliceLocked *NONNULL_PTR obj);
40087 export function SpliceLocked_write(obj: bigint): number {
40088 if(!isWasmInitialized) {
40089 throw new Error("initializeWasm() must be awaited first!");
40091 const nativeResponseValue = wasm.TS_SpliceLocked_write(obj);
40092 return nativeResponseValue;
40094 // struct LDKCResult_SpliceLockedDecodeErrorZ SpliceLocked_read(struct LDKu8slice ser);
40096 export function SpliceLocked_read(ser: number): bigint {
40097 if(!isWasmInitialized) {
40098 throw new Error("initializeWasm() must be awaited first!");
40100 const nativeResponseValue = wasm.TS_SpliceLocked_read(ser);
40101 return nativeResponseValue;
40103 // struct LDKCVec_u8Z TxAddInput_write(const struct LDKTxAddInput *NONNULL_PTR obj);
40105 export function TxAddInput_write(obj: bigint): number {
40106 if(!isWasmInitialized) {
40107 throw new Error("initializeWasm() must be awaited first!");
40109 const nativeResponseValue = wasm.TS_TxAddInput_write(obj);
40110 return nativeResponseValue;
40112 // struct LDKCResult_TxAddInputDecodeErrorZ TxAddInput_read(struct LDKu8slice ser);
40114 export function TxAddInput_read(ser: number): bigint {
40115 if(!isWasmInitialized) {
40116 throw new Error("initializeWasm() must be awaited first!");
40118 const nativeResponseValue = wasm.TS_TxAddInput_read(ser);
40119 return nativeResponseValue;
40121 // struct LDKCVec_u8Z TxAddOutput_write(const struct LDKTxAddOutput *NONNULL_PTR obj);
40123 export function TxAddOutput_write(obj: bigint): number {
40124 if(!isWasmInitialized) {
40125 throw new Error("initializeWasm() must be awaited first!");
40127 const nativeResponseValue = wasm.TS_TxAddOutput_write(obj);
40128 return nativeResponseValue;
40130 // struct LDKCResult_TxAddOutputDecodeErrorZ TxAddOutput_read(struct LDKu8slice ser);
40132 export function TxAddOutput_read(ser: number): bigint {
40133 if(!isWasmInitialized) {
40134 throw new Error("initializeWasm() must be awaited first!");
40136 const nativeResponseValue = wasm.TS_TxAddOutput_read(ser);
40137 return nativeResponseValue;
40139 // struct LDKCVec_u8Z TxRemoveInput_write(const struct LDKTxRemoveInput *NONNULL_PTR obj);
40141 export function TxRemoveInput_write(obj: bigint): number {
40142 if(!isWasmInitialized) {
40143 throw new Error("initializeWasm() must be awaited first!");
40145 const nativeResponseValue = wasm.TS_TxRemoveInput_write(obj);
40146 return nativeResponseValue;
40148 // struct LDKCResult_TxRemoveInputDecodeErrorZ TxRemoveInput_read(struct LDKu8slice ser);
40150 export function TxRemoveInput_read(ser: number): bigint {
40151 if(!isWasmInitialized) {
40152 throw new Error("initializeWasm() must be awaited first!");
40154 const nativeResponseValue = wasm.TS_TxRemoveInput_read(ser);
40155 return nativeResponseValue;
40157 // struct LDKCVec_u8Z TxRemoveOutput_write(const struct LDKTxRemoveOutput *NONNULL_PTR obj);
40159 export function TxRemoveOutput_write(obj: bigint): number {
40160 if(!isWasmInitialized) {
40161 throw new Error("initializeWasm() must be awaited first!");
40163 const nativeResponseValue = wasm.TS_TxRemoveOutput_write(obj);
40164 return nativeResponseValue;
40166 // struct LDKCResult_TxRemoveOutputDecodeErrorZ TxRemoveOutput_read(struct LDKu8slice ser);
40168 export function TxRemoveOutput_read(ser: number): bigint {
40169 if(!isWasmInitialized) {
40170 throw new Error("initializeWasm() must be awaited first!");
40172 const nativeResponseValue = wasm.TS_TxRemoveOutput_read(ser);
40173 return nativeResponseValue;
40175 // struct LDKCVec_u8Z TxComplete_write(const struct LDKTxComplete *NONNULL_PTR obj);
40177 export function TxComplete_write(obj: bigint): number {
40178 if(!isWasmInitialized) {
40179 throw new Error("initializeWasm() must be awaited first!");
40181 const nativeResponseValue = wasm.TS_TxComplete_write(obj);
40182 return nativeResponseValue;
40184 // struct LDKCResult_TxCompleteDecodeErrorZ TxComplete_read(struct LDKu8slice ser);
40186 export function TxComplete_read(ser: number): bigint {
40187 if(!isWasmInitialized) {
40188 throw new Error("initializeWasm() must be awaited first!");
40190 const nativeResponseValue = wasm.TS_TxComplete_read(ser);
40191 return nativeResponseValue;
40193 // struct LDKCVec_u8Z TxSignatures_write(const struct LDKTxSignatures *NONNULL_PTR obj);
40195 export function TxSignatures_write(obj: bigint): number {
40196 if(!isWasmInitialized) {
40197 throw new Error("initializeWasm() must be awaited first!");
40199 const nativeResponseValue = wasm.TS_TxSignatures_write(obj);
40200 return nativeResponseValue;
40202 // struct LDKCResult_TxSignaturesDecodeErrorZ TxSignatures_read(struct LDKu8slice ser);
40204 export function TxSignatures_read(ser: number): bigint {
40205 if(!isWasmInitialized) {
40206 throw new Error("initializeWasm() must be awaited first!");
40208 const nativeResponseValue = wasm.TS_TxSignatures_read(ser);
40209 return nativeResponseValue;
40211 // struct LDKCVec_u8Z TxInitRbf_write(const struct LDKTxInitRbf *NONNULL_PTR obj);
40213 export function TxInitRbf_write(obj: bigint): number {
40214 if(!isWasmInitialized) {
40215 throw new Error("initializeWasm() must be awaited first!");
40217 const nativeResponseValue = wasm.TS_TxInitRbf_write(obj);
40218 return nativeResponseValue;
40220 // struct LDKCResult_TxInitRbfDecodeErrorZ TxInitRbf_read(struct LDKu8slice ser);
40222 export function TxInitRbf_read(ser: number): bigint {
40223 if(!isWasmInitialized) {
40224 throw new Error("initializeWasm() must be awaited first!");
40226 const nativeResponseValue = wasm.TS_TxInitRbf_read(ser);
40227 return nativeResponseValue;
40229 // struct LDKCVec_u8Z TxAckRbf_write(const struct LDKTxAckRbf *NONNULL_PTR obj);
40231 export function TxAckRbf_write(obj: bigint): number {
40232 if(!isWasmInitialized) {
40233 throw new Error("initializeWasm() must be awaited first!");
40235 const nativeResponseValue = wasm.TS_TxAckRbf_write(obj);
40236 return nativeResponseValue;
40238 // struct LDKCResult_TxAckRbfDecodeErrorZ TxAckRbf_read(struct LDKu8slice ser);
40240 export function TxAckRbf_read(ser: number): bigint {
40241 if(!isWasmInitialized) {
40242 throw new Error("initializeWasm() must be awaited first!");
40244 const nativeResponseValue = wasm.TS_TxAckRbf_read(ser);
40245 return nativeResponseValue;
40247 // struct LDKCVec_u8Z TxAbort_write(const struct LDKTxAbort *NONNULL_PTR obj);
40249 export function TxAbort_write(obj: bigint): number {
40250 if(!isWasmInitialized) {
40251 throw new Error("initializeWasm() must be awaited first!");
40253 const nativeResponseValue = wasm.TS_TxAbort_write(obj);
40254 return nativeResponseValue;
40256 // struct LDKCResult_TxAbortDecodeErrorZ TxAbort_read(struct LDKu8slice ser);
40258 export function TxAbort_read(ser: number): bigint {
40259 if(!isWasmInitialized) {
40260 throw new Error("initializeWasm() must be awaited first!");
40262 const nativeResponseValue = wasm.TS_TxAbort_read(ser);
40263 return nativeResponseValue;
40265 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
40267 export function AnnouncementSignatures_write(obj: bigint): number {
40268 if(!isWasmInitialized) {
40269 throw new Error("initializeWasm() must be awaited first!");
40271 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
40272 return nativeResponseValue;
40274 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
40276 export function AnnouncementSignatures_read(ser: number): bigint {
40277 if(!isWasmInitialized) {
40278 throw new Error("initializeWasm() must be awaited first!");
40280 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
40281 return nativeResponseValue;
40283 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
40285 export function ChannelReestablish_write(obj: bigint): number {
40286 if(!isWasmInitialized) {
40287 throw new Error("initializeWasm() must be awaited first!");
40289 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
40290 return nativeResponseValue;
40292 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
40294 export function ChannelReestablish_read(ser: number): bigint {
40295 if(!isWasmInitialized) {
40296 throw new Error("initializeWasm() must be awaited first!");
40298 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
40299 return nativeResponseValue;
40301 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
40303 export function ClosingSigned_write(obj: bigint): number {
40304 if(!isWasmInitialized) {
40305 throw new Error("initializeWasm() must be awaited first!");
40307 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
40308 return nativeResponseValue;
40310 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
40312 export function ClosingSigned_read(ser: number): bigint {
40313 if(!isWasmInitialized) {
40314 throw new Error("initializeWasm() must be awaited first!");
40316 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
40317 return nativeResponseValue;
40319 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
40321 export function ClosingSignedFeeRange_write(obj: bigint): number {
40322 if(!isWasmInitialized) {
40323 throw new Error("initializeWasm() must be awaited first!");
40325 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
40326 return nativeResponseValue;
40328 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
40330 export function ClosingSignedFeeRange_read(ser: number): bigint {
40331 if(!isWasmInitialized) {
40332 throw new Error("initializeWasm() must be awaited first!");
40334 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
40335 return nativeResponseValue;
40337 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
40339 export function CommitmentSigned_write(obj: bigint): number {
40340 if(!isWasmInitialized) {
40341 throw new Error("initializeWasm() must be awaited first!");
40343 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
40344 return nativeResponseValue;
40346 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
40348 export function CommitmentSigned_read(ser: number): bigint {
40349 if(!isWasmInitialized) {
40350 throw new Error("initializeWasm() must be awaited first!");
40352 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
40353 return nativeResponseValue;
40355 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
40357 export function FundingCreated_write(obj: bigint): number {
40358 if(!isWasmInitialized) {
40359 throw new Error("initializeWasm() must be awaited first!");
40361 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
40362 return nativeResponseValue;
40364 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
40366 export function FundingCreated_read(ser: number): bigint {
40367 if(!isWasmInitialized) {
40368 throw new Error("initializeWasm() must be awaited first!");
40370 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
40371 return nativeResponseValue;
40373 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
40375 export function FundingSigned_write(obj: bigint): number {
40376 if(!isWasmInitialized) {
40377 throw new Error("initializeWasm() must be awaited first!");
40379 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
40380 return nativeResponseValue;
40382 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
40384 export function FundingSigned_read(ser: number): bigint {
40385 if(!isWasmInitialized) {
40386 throw new Error("initializeWasm() must be awaited first!");
40388 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
40389 return nativeResponseValue;
40391 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
40393 export function ChannelReady_write(obj: bigint): number {
40394 if(!isWasmInitialized) {
40395 throw new Error("initializeWasm() must be awaited first!");
40397 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
40398 return nativeResponseValue;
40400 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
40402 export function ChannelReady_read(ser: number): bigint {
40403 if(!isWasmInitialized) {
40404 throw new Error("initializeWasm() must be awaited first!");
40406 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
40407 return nativeResponseValue;
40409 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
40411 export function Init_write(obj: bigint): number {
40412 if(!isWasmInitialized) {
40413 throw new Error("initializeWasm() must be awaited first!");
40415 const nativeResponseValue = wasm.TS_Init_write(obj);
40416 return nativeResponseValue;
40418 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
40420 export function Init_read(ser: number): bigint {
40421 if(!isWasmInitialized) {
40422 throw new Error("initializeWasm() must be awaited first!");
40424 const nativeResponseValue = wasm.TS_Init_read(ser);
40425 return nativeResponseValue;
40427 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
40429 export function OpenChannel_write(obj: bigint): number {
40430 if(!isWasmInitialized) {
40431 throw new Error("initializeWasm() must be awaited first!");
40433 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
40434 return nativeResponseValue;
40436 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
40438 export function OpenChannel_read(ser: number): bigint {
40439 if(!isWasmInitialized) {
40440 throw new Error("initializeWasm() must be awaited first!");
40442 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
40443 return nativeResponseValue;
40445 // struct LDKCVec_u8Z OpenChannelV2_write(const struct LDKOpenChannelV2 *NONNULL_PTR obj);
40447 export function OpenChannelV2_write(obj: bigint): number {
40448 if(!isWasmInitialized) {
40449 throw new Error("initializeWasm() must be awaited first!");
40451 const nativeResponseValue = wasm.TS_OpenChannelV2_write(obj);
40452 return nativeResponseValue;
40454 // struct LDKCResult_OpenChannelV2DecodeErrorZ OpenChannelV2_read(struct LDKu8slice ser);
40456 export function OpenChannelV2_read(ser: number): bigint {
40457 if(!isWasmInitialized) {
40458 throw new Error("initializeWasm() must be awaited first!");
40460 const nativeResponseValue = wasm.TS_OpenChannelV2_read(ser);
40461 return nativeResponseValue;
40463 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
40465 export function RevokeAndACK_write(obj: bigint): number {
40466 if(!isWasmInitialized) {
40467 throw new Error("initializeWasm() must be awaited first!");
40469 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
40470 return nativeResponseValue;
40472 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
40474 export function RevokeAndACK_read(ser: number): bigint {
40475 if(!isWasmInitialized) {
40476 throw new Error("initializeWasm() must be awaited first!");
40478 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
40479 return nativeResponseValue;
40481 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
40483 export function Shutdown_write(obj: bigint): number {
40484 if(!isWasmInitialized) {
40485 throw new Error("initializeWasm() must be awaited first!");
40487 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
40488 return nativeResponseValue;
40490 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
40492 export function Shutdown_read(ser: number): bigint {
40493 if(!isWasmInitialized) {
40494 throw new Error("initializeWasm() must be awaited first!");
40496 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
40497 return nativeResponseValue;
40499 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
40501 export function UpdateFailHTLC_write(obj: bigint): number {
40502 if(!isWasmInitialized) {
40503 throw new Error("initializeWasm() must be awaited first!");
40505 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
40506 return nativeResponseValue;
40508 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
40510 export function UpdateFailHTLC_read(ser: number): bigint {
40511 if(!isWasmInitialized) {
40512 throw new Error("initializeWasm() must be awaited first!");
40514 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
40515 return nativeResponseValue;
40517 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
40519 export function UpdateFailMalformedHTLC_write(obj: bigint): number {
40520 if(!isWasmInitialized) {
40521 throw new Error("initializeWasm() must be awaited first!");
40523 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
40524 return nativeResponseValue;
40526 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
40528 export function UpdateFailMalformedHTLC_read(ser: number): bigint {
40529 if(!isWasmInitialized) {
40530 throw new Error("initializeWasm() must be awaited first!");
40532 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
40533 return nativeResponseValue;
40535 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
40537 export function UpdateFee_write(obj: bigint): number {
40538 if(!isWasmInitialized) {
40539 throw new Error("initializeWasm() must be awaited first!");
40541 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
40542 return nativeResponseValue;
40544 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
40546 export function UpdateFee_read(ser: number): bigint {
40547 if(!isWasmInitialized) {
40548 throw new Error("initializeWasm() must be awaited first!");
40550 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
40551 return nativeResponseValue;
40553 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
40555 export function UpdateFulfillHTLC_write(obj: bigint): number {
40556 if(!isWasmInitialized) {
40557 throw new Error("initializeWasm() must be awaited first!");
40559 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
40560 return nativeResponseValue;
40562 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
40564 export function UpdateFulfillHTLC_read(ser: number): bigint {
40565 if(!isWasmInitialized) {
40566 throw new Error("initializeWasm() must be awaited first!");
40568 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
40569 return nativeResponseValue;
40571 // struct LDKCVec_u8Z OnionPacket_write(const struct LDKOnionPacket *NONNULL_PTR obj);
40573 export function OnionPacket_write(obj: bigint): number {
40574 if(!isWasmInitialized) {
40575 throw new Error("initializeWasm() must be awaited first!");
40577 const nativeResponseValue = wasm.TS_OnionPacket_write(obj);
40578 return nativeResponseValue;
40580 // struct LDKCResult_OnionPacketDecodeErrorZ OnionPacket_read(struct LDKu8slice ser);
40582 export function OnionPacket_read(ser: number): bigint {
40583 if(!isWasmInitialized) {
40584 throw new Error("initializeWasm() must be awaited first!");
40586 const nativeResponseValue = wasm.TS_OnionPacket_read(ser);
40587 return nativeResponseValue;
40589 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
40591 export function UpdateAddHTLC_write(obj: bigint): number {
40592 if(!isWasmInitialized) {
40593 throw new Error("initializeWasm() must be awaited first!");
40595 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
40596 return nativeResponseValue;
40598 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
40600 export function UpdateAddHTLC_read(ser: number): bigint {
40601 if(!isWasmInitialized) {
40602 throw new Error("initializeWasm() must be awaited first!");
40604 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
40605 return nativeResponseValue;
40607 // struct LDKCResult_OnionMessageDecodeErrorZ OnionMessage_read(struct LDKu8slice ser);
40609 export function OnionMessage_read(ser: number): bigint {
40610 if(!isWasmInitialized) {
40611 throw new Error("initializeWasm() must be awaited first!");
40613 const nativeResponseValue = wasm.TS_OnionMessage_read(ser);
40614 return nativeResponseValue;
40616 // struct LDKCVec_u8Z OnionMessage_write(const struct LDKOnionMessage *NONNULL_PTR obj);
40618 export function OnionMessage_write(obj: bigint): number {
40619 if(!isWasmInitialized) {
40620 throw new Error("initializeWasm() must be awaited first!");
40622 const nativeResponseValue = wasm.TS_OnionMessage_write(obj);
40623 return nativeResponseValue;
40625 // struct LDKCVec_u8Z FinalOnionHopData_write(const struct LDKFinalOnionHopData *NONNULL_PTR obj);
40627 export function FinalOnionHopData_write(obj: bigint): number {
40628 if(!isWasmInitialized) {
40629 throw new Error("initializeWasm() must be awaited first!");
40631 const nativeResponseValue = wasm.TS_FinalOnionHopData_write(obj);
40632 return nativeResponseValue;
40634 // struct LDKCResult_FinalOnionHopDataDecodeErrorZ FinalOnionHopData_read(struct LDKu8slice ser);
40636 export function FinalOnionHopData_read(ser: number): bigint {
40637 if(!isWasmInitialized) {
40638 throw new Error("initializeWasm() must be awaited first!");
40640 const nativeResponseValue = wasm.TS_FinalOnionHopData_read(ser);
40641 return nativeResponseValue;
40643 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
40645 export function Ping_write(obj: bigint): number {
40646 if(!isWasmInitialized) {
40647 throw new Error("initializeWasm() must be awaited first!");
40649 const nativeResponseValue = wasm.TS_Ping_write(obj);
40650 return nativeResponseValue;
40652 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
40654 export function Ping_read(ser: number): bigint {
40655 if(!isWasmInitialized) {
40656 throw new Error("initializeWasm() must be awaited first!");
40658 const nativeResponseValue = wasm.TS_Ping_read(ser);
40659 return nativeResponseValue;
40661 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
40663 export function Pong_write(obj: bigint): number {
40664 if(!isWasmInitialized) {
40665 throw new Error("initializeWasm() must be awaited first!");
40667 const nativeResponseValue = wasm.TS_Pong_write(obj);
40668 return nativeResponseValue;
40670 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
40672 export function Pong_read(ser: number): bigint {
40673 if(!isWasmInitialized) {
40674 throw new Error("initializeWasm() must be awaited first!");
40676 const nativeResponseValue = wasm.TS_Pong_read(ser);
40677 return nativeResponseValue;
40679 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
40681 export function UnsignedChannelAnnouncement_write(obj: bigint): number {
40682 if(!isWasmInitialized) {
40683 throw new Error("initializeWasm() must be awaited first!");
40685 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
40686 return nativeResponseValue;
40688 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
40690 export function UnsignedChannelAnnouncement_read(ser: number): bigint {
40691 if(!isWasmInitialized) {
40692 throw new Error("initializeWasm() must be awaited first!");
40694 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
40695 return nativeResponseValue;
40697 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
40699 export function ChannelAnnouncement_write(obj: bigint): number {
40700 if(!isWasmInitialized) {
40701 throw new Error("initializeWasm() must be awaited first!");
40703 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
40704 return nativeResponseValue;
40706 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
40708 export function ChannelAnnouncement_read(ser: number): bigint {
40709 if(!isWasmInitialized) {
40710 throw new Error("initializeWasm() must be awaited first!");
40712 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
40713 return nativeResponseValue;
40715 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
40717 export function UnsignedChannelUpdate_write(obj: bigint): number {
40718 if(!isWasmInitialized) {
40719 throw new Error("initializeWasm() must be awaited first!");
40721 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
40722 return nativeResponseValue;
40724 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
40726 export function UnsignedChannelUpdate_read(ser: number): bigint {
40727 if(!isWasmInitialized) {
40728 throw new Error("initializeWasm() must be awaited first!");
40730 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
40731 return nativeResponseValue;
40733 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
40735 export function ChannelUpdate_write(obj: bigint): number {
40736 if(!isWasmInitialized) {
40737 throw new Error("initializeWasm() must be awaited first!");
40739 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
40740 return nativeResponseValue;
40742 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
40744 export function ChannelUpdate_read(ser: number): bigint {
40745 if(!isWasmInitialized) {
40746 throw new Error("initializeWasm() must be awaited first!");
40748 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
40749 return nativeResponseValue;
40751 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
40753 export function ErrorMessage_write(obj: bigint): number {
40754 if(!isWasmInitialized) {
40755 throw new Error("initializeWasm() must be awaited first!");
40757 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
40758 return nativeResponseValue;
40760 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
40762 export function ErrorMessage_read(ser: number): bigint {
40763 if(!isWasmInitialized) {
40764 throw new Error("initializeWasm() must be awaited first!");
40766 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
40767 return nativeResponseValue;
40769 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
40771 export function WarningMessage_write(obj: bigint): number {
40772 if(!isWasmInitialized) {
40773 throw new Error("initializeWasm() must be awaited first!");
40775 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
40776 return nativeResponseValue;
40778 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
40780 export function WarningMessage_read(ser: number): bigint {
40781 if(!isWasmInitialized) {
40782 throw new Error("initializeWasm() must be awaited first!");
40784 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
40785 return nativeResponseValue;
40787 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
40789 export function UnsignedNodeAnnouncement_write(obj: bigint): number {
40790 if(!isWasmInitialized) {
40791 throw new Error("initializeWasm() must be awaited first!");
40793 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
40794 return nativeResponseValue;
40796 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
40798 export function UnsignedNodeAnnouncement_read(ser: number): bigint {
40799 if(!isWasmInitialized) {
40800 throw new Error("initializeWasm() must be awaited first!");
40802 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
40803 return nativeResponseValue;
40805 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
40807 export function NodeAnnouncement_write(obj: bigint): number {
40808 if(!isWasmInitialized) {
40809 throw new Error("initializeWasm() must be awaited first!");
40811 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
40812 return nativeResponseValue;
40814 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
40816 export function NodeAnnouncement_read(ser: number): bigint {
40817 if(!isWasmInitialized) {
40818 throw new Error("initializeWasm() must be awaited first!");
40820 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
40821 return nativeResponseValue;
40823 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
40825 export function QueryShortChannelIds_read(ser: number): bigint {
40826 if(!isWasmInitialized) {
40827 throw new Error("initializeWasm() must be awaited first!");
40829 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
40830 return nativeResponseValue;
40832 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
40834 export function QueryShortChannelIds_write(obj: bigint): number {
40835 if(!isWasmInitialized) {
40836 throw new Error("initializeWasm() must be awaited first!");
40838 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
40839 return nativeResponseValue;
40841 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
40843 export function ReplyShortChannelIdsEnd_write(obj: bigint): number {
40844 if(!isWasmInitialized) {
40845 throw new Error("initializeWasm() must be awaited first!");
40847 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
40848 return nativeResponseValue;
40850 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
40852 export function ReplyShortChannelIdsEnd_read(ser: number): bigint {
40853 if(!isWasmInitialized) {
40854 throw new Error("initializeWasm() must be awaited first!");
40856 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
40857 return nativeResponseValue;
40859 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
40861 export function QueryChannelRange_end_blocknum(this_arg: bigint): number {
40862 if(!isWasmInitialized) {
40863 throw new Error("initializeWasm() must be awaited first!");
40865 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
40866 return nativeResponseValue;
40868 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
40870 export function QueryChannelRange_write(obj: bigint): number {
40871 if(!isWasmInitialized) {
40872 throw new Error("initializeWasm() must be awaited first!");
40874 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
40875 return nativeResponseValue;
40877 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
40879 export function QueryChannelRange_read(ser: number): bigint {
40880 if(!isWasmInitialized) {
40881 throw new Error("initializeWasm() must be awaited first!");
40883 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
40884 return nativeResponseValue;
40886 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
40888 export function ReplyChannelRange_read(ser: number): bigint {
40889 if(!isWasmInitialized) {
40890 throw new Error("initializeWasm() must be awaited first!");
40892 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
40893 return nativeResponseValue;
40895 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
40897 export function ReplyChannelRange_write(obj: bigint): number {
40898 if(!isWasmInitialized) {
40899 throw new Error("initializeWasm() must be awaited first!");
40901 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
40902 return nativeResponseValue;
40904 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
40906 export function GossipTimestampFilter_write(obj: bigint): number {
40907 if(!isWasmInitialized) {
40908 throw new Error("initializeWasm() must be awaited first!");
40910 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
40911 return nativeResponseValue;
40913 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
40915 export function GossipTimestampFilter_read(ser: number): bigint {
40916 if(!isWasmInitialized) {
40917 throw new Error("initializeWasm() must be awaited first!");
40919 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
40920 return nativeResponseValue;
40922 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
40924 export function CustomMessageHandler_free(this_ptr: bigint): void {
40925 if(!isWasmInitialized) {
40926 throw new Error("initializeWasm() must be awaited first!");
40928 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
40929 // debug statements here
40931 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
40933 export function IgnoringMessageHandler_free(this_obj: bigint): void {
40934 if(!isWasmInitialized) {
40935 throw new Error("initializeWasm() must be awaited first!");
40937 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
40938 // debug statements here
40940 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
40942 export function IgnoringMessageHandler_new(): bigint {
40943 if(!isWasmInitialized) {
40944 throw new Error("initializeWasm() must be awaited first!");
40946 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
40947 return nativeResponseValue;
40949 // struct LDKEventsProvider IgnoringMessageHandler_as_EventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
40951 export function IgnoringMessageHandler_as_EventsProvider(this_arg: bigint): bigint {
40952 if(!isWasmInitialized) {
40953 throw new Error("initializeWasm() must be awaited first!");
40955 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_EventsProvider(this_arg);
40956 return nativeResponseValue;
40958 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
40960 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
40961 if(!isWasmInitialized) {
40962 throw new Error("initializeWasm() must be awaited first!");
40964 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
40965 return nativeResponseValue;
40967 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
40969 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: bigint): bigint {
40970 if(!isWasmInitialized) {
40971 throw new Error("initializeWasm() must be awaited first!");
40973 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
40974 return nativeResponseValue;
40976 // struct LDKOnionMessageHandler IgnoringMessageHandler_as_OnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
40978 export function IgnoringMessageHandler_as_OnionMessageHandler(this_arg: bigint): bigint {
40979 if(!isWasmInitialized) {
40980 throw new Error("initializeWasm() must be awaited first!");
40982 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OnionMessageHandler(this_arg);
40983 return nativeResponseValue;
40985 // struct LDKOffersMessageHandler IgnoringMessageHandler_as_OffersMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
40987 export function IgnoringMessageHandler_as_OffersMessageHandler(this_arg: bigint): bigint {
40988 if(!isWasmInitialized) {
40989 throw new Error("initializeWasm() must be awaited first!");
40991 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_OffersMessageHandler(this_arg);
40992 return nativeResponseValue;
40994 // struct LDKCustomOnionMessageHandler IgnoringMessageHandler_as_CustomOnionMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
40996 export function IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg: bigint): bigint {
40997 if(!isWasmInitialized) {
40998 throw new Error("initializeWasm() must be awaited first!");
41000 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(this_arg);
41001 return nativeResponseValue;
41003 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
41005 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: bigint): bigint {
41006 if(!isWasmInitialized) {
41007 throw new Error("initializeWasm() must be awaited first!");
41009 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
41010 return nativeResponseValue;
41012 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
41014 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: bigint): bigint {
41015 if(!isWasmInitialized) {
41016 throw new Error("initializeWasm() must be awaited first!");
41018 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
41019 return nativeResponseValue;
41021 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
41023 export function ErroringMessageHandler_free(this_obj: bigint): void {
41024 if(!isWasmInitialized) {
41025 throw new Error("initializeWasm() must be awaited first!");
41027 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
41028 // debug statements here
41030 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
41032 export function ErroringMessageHandler_new(): bigint {
41033 if(!isWasmInitialized) {
41034 throw new Error("initializeWasm() must be awaited first!");
41036 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
41037 return nativeResponseValue;
41039 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
41041 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: bigint): bigint {
41042 if(!isWasmInitialized) {
41043 throw new Error("initializeWasm() must be awaited first!");
41045 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
41046 return nativeResponseValue;
41048 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
41050 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: bigint): bigint {
41051 if(!isWasmInitialized) {
41052 throw new Error("initializeWasm() must be awaited first!");
41054 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
41055 return nativeResponseValue;
41057 // void MessageHandler_free(struct LDKMessageHandler this_obj);
41059 export function MessageHandler_free(this_obj: bigint): void {
41060 if(!isWasmInitialized) {
41061 throw new Error("initializeWasm() must be awaited first!");
41063 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
41064 // debug statements here
41066 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
41068 export function MessageHandler_get_chan_handler(this_ptr: bigint): bigint {
41069 if(!isWasmInitialized) {
41070 throw new Error("initializeWasm() must be awaited first!");
41072 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
41073 return nativeResponseValue;
41075 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
41077 export function MessageHandler_set_chan_handler(this_ptr: bigint, val: bigint): void {
41078 if(!isWasmInitialized) {
41079 throw new Error("initializeWasm() must be awaited first!");
41081 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
41082 // debug statements here
41084 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
41086 export function MessageHandler_get_route_handler(this_ptr: bigint): bigint {
41087 if(!isWasmInitialized) {
41088 throw new Error("initializeWasm() must be awaited first!");
41090 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
41091 return nativeResponseValue;
41093 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
41095 export function MessageHandler_set_route_handler(this_ptr: bigint, val: bigint): void {
41096 if(!isWasmInitialized) {
41097 throw new Error("initializeWasm() must be awaited first!");
41099 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
41100 // debug statements here
41102 // const struct LDKOnionMessageHandler *MessageHandler_get_onion_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
41104 export function MessageHandler_get_onion_message_handler(this_ptr: bigint): bigint {
41105 if(!isWasmInitialized) {
41106 throw new Error("initializeWasm() must be awaited first!");
41108 const nativeResponseValue = wasm.TS_MessageHandler_get_onion_message_handler(this_ptr);
41109 return nativeResponseValue;
41111 // void MessageHandler_set_onion_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKOnionMessageHandler val);
41113 export function MessageHandler_set_onion_message_handler(this_ptr: bigint, val: bigint): void {
41114 if(!isWasmInitialized) {
41115 throw new Error("initializeWasm() must be awaited first!");
41117 const nativeResponseValue = wasm.TS_MessageHandler_set_onion_message_handler(this_ptr, val);
41118 // debug statements here
41120 // const struct LDKCustomMessageHandler *MessageHandler_get_custom_message_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
41122 export function MessageHandler_get_custom_message_handler(this_ptr: bigint): bigint {
41123 if(!isWasmInitialized) {
41124 throw new Error("initializeWasm() must be awaited first!");
41126 const nativeResponseValue = wasm.TS_MessageHandler_get_custom_message_handler(this_ptr);
41127 return nativeResponseValue;
41129 // void MessageHandler_set_custom_message_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKCustomMessageHandler val);
41131 export function MessageHandler_set_custom_message_handler(this_ptr: bigint, val: bigint): void {
41132 if(!isWasmInitialized) {
41133 throw new Error("initializeWasm() must be awaited first!");
41135 const nativeResponseValue = wasm.TS_MessageHandler_set_custom_message_handler(this_ptr, val);
41136 // debug statements here
41138 // 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);
41140 export function MessageHandler_new(chan_handler_arg: bigint, route_handler_arg: bigint, onion_message_handler_arg: bigint, custom_message_handler_arg: bigint): bigint {
41141 if(!isWasmInitialized) {
41142 throw new Error("initializeWasm() must be awaited first!");
41144 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg, onion_message_handler_arg, custom_message_handler_arg);
41145 return nativeResponseValue;
41147 // uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
41149 export function SocketDescriptor_clone_ptr(arg: bigint): bigint {
41150 if(!isWasmInitialized) {
41151 throw new Error("initializeWasm() must be awaited first!");
41153 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
41154 return nativeResponseValue;
41156 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
41158 export function SocketDescriptor_clone(orig: bigint): bigint {
41159 if(!isWasmInitialized) {
41160 throw new Error("initializeWasm() must be awaited first!");
41162 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
41163 return nativeResponseValue;
41165 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
41167 export function SocketDescriptor_free(this_ptr: bigint): void {
41168 if(!isWasmInitialized) {
41169 throw new Error("initializeWasm() must be awaited first!");
41171 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
41172 // debug statements here
41174 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
41176 export function PeerHandleError_free(this_obj: bigint): void {
41177 if(!isWasmInitialized) {
41178 throw new Error("initializeWasm() must be awaited first!");
41180 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
41181 // debug statements here
41183 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(void);
41185 export function PeerHandleError_new(): bigint {
41186 if(!isWasmInitialized) {
41187 throw new Error("initializeWasm() must be awaited first!");
41189 const nativeResponseValue = wasm.TS_PeerHandleError_new();
41190 return nativeResponseValue;
41192 // uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
41194 export function PeerHandleError_clone_ptr(arg: bigint): bigint {
41195 if(!isWasmInitialized) {
41196 throw new Error("initializeWasm() must be awaited first!");
41198 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
41199 return nativeResponseValue;
41201 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
41203 export function PeerHandleError_clone(orig: bigint): bigint {
41204 if(!isWasmInitialized) {
41205 throw new Error("initializeWasm() must be awaited first!");
41207 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
41208 return nativeResponseValue;
41210 // void PeerManager_free(struct LDKPeerManager this_obj);
41212 export function PeerManager_free(this_obj: bigint): void {
41213 if(!isWasmInitialized) {
41214 throw new Error("initializeWasm() must be awaited first!");
41216 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
41217 // debug statements here
41219 // 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);
41221 export function PeerManager_new(message_handler: bigint, current_time: number, ephemeral_random_data: number, logger: bigint, node_signer: bigint): bigint {
41222 if(!isWasmInitialized) {
41223 throw new Error("initializeWasm() must be awaited first!");
41225 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, current_time, ephemeral_random_data, logger, node_signer);
41226 return nativeResponseValue;
41228 // MUST_USE_RES struct LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
41230 export function PeerManager_get_peer_node_ids(this_arg: bigint): number {
41231 if(!isWasmInitialized) {
41232 throw new Error("initializeWasm() must be awaited first!");
41234 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
41235 return nativeResponseValue;
41237 // 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);
41239 export function PeerManager_new_outbound_connection(this_arg: bigint, their_node_id: number, descriptor: bigint, remote_network_address: bigint): bigint {
41240 if(!isWasmInitialized) {
41241 throw new Error("initializeWasm() must be awaited first!");
41243 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
41244 return nativeResponseValue;
41246 // 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);
41248 export function PeerManager_new_inbound_connection(this_arg: bigint, descriptor: bigint, remote_network_address: bigint): bigint {
41249 if(!isWasmInitialized) {
41250 throw new Error("initializeWasm() must be awaited first!");
41252 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
41253 return nativeResponseValue;
41255 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
41257 export function PeerManager_write_buffer_space_avail(this_arg: bigint, descriptor: bigint): bigint {
41258 if(!isWasmInitialized) {
41259 throw new Error("initializeWasm() must be awaited first!");
41261 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
41262 return nativeResponseValue;
41264 // 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);
41266 export function PeerManager_read_event(this_arg: bigint, peer_descriptor: bigint, data: number): bigint {
41267 if(!isWasmInitialized) {
41268 throw new Error("initializeWasm() must be awaited first!");
41270 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
41271 return nativeResponseValue;
41273 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
41275 export function PeerManager_process_events(this_arg: bigint): void {
41276 if(!isWasmInitialized) {
41277 throw new Error("initializeWasm() must be awaited first!");
41279 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
41280 // debug statements here
41282 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
41284 export function PeerManager_socket_disconnected(this_arg: bigint, descriptor: bigint): void {
41285 if(!isWasmInitialized) {
41286 throw new Error("initializeWasm() must be awaited first!");
41288 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
41289 // debug statements here
41291 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
41293 export function PeerManager_disconnect_by_node_id(this_arg: bigint, node_id: number): void {
41294 if(!isWasmInitialized) {
41295 throw new Error("initializeWasm() must be awaited first!");
41297 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id);
41298 // debug statements here
41300 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
41302 export function PeerManager_disconnect_all_peers(this_arg: bigint): void {
41303 if(!isWasmInitialized) {
41304 throw new Error("initializeWasm() must be awaited first!");
41306 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
41307 // debug statements here
41309 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
41311 export function PeerManager_timer_tick_occurred(this_arg: bigint): void {
41312 if(!isWasmInitialized) {
41313 throw new Error("initializeWasm() must be awaited first!");
41315 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
41316 // debug statements here
41318 // void PeerManager_broadcast_node_announcement(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_SocketAddressZ addresses);
41320 export function PeerManager_broadcast_node_announcement(this_arg: bigint, rgb: number, alias: number, addresses: number): void {
41321 if(!isWasmInitialized) {
41322 throw new Error("initializeWasm() must be awaited first!");
41324 const nativeResponseValue = wasm.TS_PeerManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
41325 // debug statements here
41327 // uint64_t htlc_success_tx_weight(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
41329 export function htlc_success_tx_weight(channel_type_features: bigint): bigint {
41330 if(!isWasmInitialized) {
41331 throw new Error("initializeWasm() must be awaited first!");
41333 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(channel_type_features);
41334 return nativeResponseValue;
41336 // uint64_t htlc_timeout_tx_weight(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features);
41338 export function htlc_timeout_tx_weight(channel_type_features: bigint): bigint {
41339 if(!isWasmInitialized) {
41340 throw new Error("initializeWasm() must be awaited first!");
41342 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(channel_type_features);
41343 return nativeResponseValue;
41345 // enum LDKHTLCClaim HTLCClaim_clone(const enum LDKHTLCClaim *NONNULL_PTR orig);
41347 export function HTLCClaim_clone(orig: bigint): HTLCClaim {
41348 if(!isWasmInitialized) {
41349 throw new Error("initializeWasm() must be awaited first!");
41351 const nativeResponseValue = wasm.TS_HTLCClaim_clone(orig);
41352 return nativeResponseValue;
41354 // enum LDKHTLCClaim HTLCClaim_offered_timeout(void);
41356 export function HTLCClaim_offered_timeout(): HTLCClaim {
41357 if(!isWasmInitialized) {
41358 throw new Error("initializeWasm() must be awaited first!");
41360 const nativeResponseValue = wasm.TS_HTLCClaim_offered_timeout();
41361 return nativeResponseValue;
41363 // enum LDKHTLCClaim HTLCClaim_offered_preimage(void);
41365 export function HTLCClaim_offered_preimage(): HTLCClaim {
41366 if(!isWasmInitialized) {
41367 throw new Error("initializeWasm() must be awaited first!");
41369 const nativeResponseValue = wasm.TS_HTLCClaim_offered_preimage();
41370 return nativeResponseValue;
41372 // enum LDKHTLCClaim HTLCClaim_accepted_timeout(void);
41374 export function HTLCClaim_accepted_timeout(): HTLCClaim {
41375 if(!isWasmInitialized) {
41376 throw new Error("initializeWasm() must be awaited first!");
41378 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_timeout();
41379 return nativeResponseValue;
41381 // enum LDKHTLCClaim HTLCClaim_accepted_preimage(void);
41383 export function HTLCClaim_accepted_preimage(): HTLCClaim {
41384 if(!isWasmInitialized) {
41385 throw new Error("initializeWasm() must be awaited first!");
41387 const nativeResponseValue = wasm.TS_HTLCClaim_accepted_preimage();
41388 return nativeResponseValue;
41390 // enum LDKHTLCClaim HTLCClaim_revocation(void);
41392 export function HTLCClaim_revocation(): HTLCClaim {
41393 if(!isWasmInitialized) {
41394 throw new Error("initializeWasm() must be awaited first!");
41396 const nativeResponseValue = wasm.TS_HTLCClaim_revocation();
41397 return nativeResponseValue;
41399 // bool HTLCClaim_eq(const enum LDKHTLCClaim *NONNULL_PTR a, const enum LDKHTLCClaim *NONNULL_PTR b);
41401 export function HTLCClaim_eq(a: bigint, b: bigint): boolean {
41402 if(!isWasmInitialized) {
41403 throw new Error("initializeWasm() must be awaited first!");
41405 const nativeResponseValue = wasm.TS_HTLCClaim_eq(a, b);
41406 return nativeResponseValue;
41408 // MUST_USE_RES struct LDKCOption_HTLCClaimZ HTLCClaim_from_witness(struct LDKWitness witness);
41410 export function HTLCClaim_from_witness(witness: number): bigint {
41411 if(!isWasmInitialized) {
41412 throw new Error("initializeWasm() must be awaited first!");
41414 const nativeResponseValue = wasm.TS_HTLCClaim_from_witness(witness);
41415 return nativeResponseValue;
41417 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
41419 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
41420 if(!isWasmInitialized) {
41421 throw new Error("initializeWasm() must be awaited first!");
41423 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
41424 return nativeResponseValue;
41426 // 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);
41428 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 {
41429 if(!isWasmInitialized) {
41430 throw new Error("initializeWasm() must be awaited first!");
41432 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
41433 return nativeResponseValue;
41435 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
41437 export function CounterpartyCommitmentSecrets_free(this_obj: bigint): void {
41438 if(!isWasmInitialized) {
41439 throw new Error("initializeWasm() must be awaited first!");
41441 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
41442 // debug statements here
41444 // uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
41446 export function CounterpartyCommitmentSecrets_clone_ptr(arg: bigint): bigint {
41447 if(!isWasmInitialized) {
41448 throw new Error("initializeWasm() must be awaited first!");
41450 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
41451 return nativeResponseValue;
41453 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
41455 export function CounterpartyCommitmentSecrets_clone(orig: bigint): bigint {
41456 if(!isWasmInitialized) {
41457 throw new Error("initializeWasm() must be awaited first!");
41459 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
41460 return nativeResponseValue;
41462 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
41464 export function CounterpartyCommitmentSecrets_new(): bigint {
41465 if(!isWasmInitialized) {
41466 throw new Error("initializeWasm() must be awaited first!");
41468 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
41469 return nativeResponseValue;
41471 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
41473 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: bigint): bigint {
41474 if(!isWasmInitialized) {
41475 throw new Error("initializeWasm() must be awaited first!");
41477 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
41478 return nativeResponseValue;
41480 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
41482 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: bigint, idx: bigint, secret: number): bigint {
41483 if(!isWasmInitialized) {
41484 throw new Error("initializeWasm() must be awaited first!");
41486 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
41487 return nativeResponseValue;
41489 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
41491 export function CounterpartyCommitmentSecrets_get_secret(this_arg: bigint, idx: bigint): number {
41492 if(!isWasmInitialized) {
41493 throw new Error("initializeWasm() must be awaited first!");
41495 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
41496 return nativeResponseValue;
41498 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
41500 export function CounterpartyCommitmentSecrets_write(obj: bigint): number {
41501 if(!isWasmInitialized) {
41502 throw new Error("initializeWasm() must be awaited first!");
41504 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
41505 return nativeResponseValue;
41507 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
41509 export function CounterpartyCommitmentSecrets_read(ser: number): bigint {
41510 if(!isWasmInitialized) {
41511 throw new Error("initializeWasm() must be awaited first!");
41513 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
41514 return nativeResponseValue;
41516 // struct LDKSecretKey derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
41518 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
41519 if(!isWasmInitialized) {
41520 throw new Error("initializeWasm() must be awaited first!");
41522 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
41523 return nativeResponseValue;
41525 // struct LDKSecretKey derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
41527 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
41528 if(!isWasmInitialized) {
41529 throw new Error("initializeWasm() must be awaited first!");
41531 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
41532 return nativeResponseValue;
41534 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
41536 export function TxCreationKeys_free(this_obj: bigint): void {
41537 if(!isWasmInitialized) {
41538 throw new Error("initializeWasm() must be awaited first!");
41540 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
41541 // debug statements here
41543 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
41545 export function TxCreationKeys_get_per_commitment_point(this_ptr: bigint): number {
41546 if(!isWasmInitialized) {
41547 throw new Error("initializeWasm() must be awaited first!");
41549 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
41550 return nativeResponseValue;
41552 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
41554 export function TxCreationKeys_set_per_commitment_point(this_ptr: bigint, val: number): void {
41555 if(!isWasmInitialized) {
41556 throw new Error("initializeWasm() must be awaited first!");
41558 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
41559 // debug statements here
41561 // struct LDKRevocationKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
41563 export function TxCreationKeys_get_revocation_key(this_ptr: bigint): bigint {
41564 if(!isWasmInitialized) {
41565 throw new Error("initializeWasm() must be awaited first!");
41567 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
41568 return nativeResponseValue;
41570 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKRevocationKey val);
41572 export function TxCreationKeys_set_revocation_key(this_ptr: bigint, val: bigint): void {
41573 if(!isWasmInitialized) {
41574 throw new Error("initializeWasm() must be awaited first!");
41576 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
41577 // debug statements here
41579 // struct LDKHtlcKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
41581 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: bigint): bigint {
41582 if(!isWasmInitialized) {
41583 throw new Error("initializeWasm() must be awaited first!");
41585 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
41586 return nativeResponseValue;
41588 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKHtlcKey val);
41590 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: bigint, val: bigint): void {
41591 if(!isWasmInitialized) {
41592 throw new Error("initializeWasm() must be awaited first!");
41594 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
41595 // debug statements here
41597 // struct LDKHtlcKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
41599 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: bigint): bigint {
41600 if(!isWasmInitialized) {
41601 throw new Error("initializeWasm() must be awaited first!");
41603 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
41604 return nativeResponseValue;
41606 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKHtlcKey val);
41608 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: bigint, val: bigint): void {
41609 if(!isWasmInitialized) {
41610 throw new Error("initializeWasm() must be awaited first!");
41612 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
41613 // debug statements here
41615 // struct LDKDelayedPaymentKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
41617 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: bigint): bigint {
41618 if(!isWasmInitialized) {
41619 throw new Error("initializeWasm() must be awaited first!");
41621 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
41622 return nativeResponseValue;
41624 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKDelayedPaymentKey val);
41626 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: bigint, val: bigint): void {
41627 if(!isWasmInitialized) {
41628 throw new Error("initializeWasm() must be awaited first!");
41630 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
41631 // debug statements here
41633 // MUST_USE_RES struct LDKTxCreationKeys TxCreationKeys_new(struct LDKPublicKey per_commitment_point_arg, struct LDKRevocationKey revocation_key_arg, struct LDKHtlcKey broadcaster_htlc_key_arg, struct LDKHtlcKey countersignatory_htlc_key_arg, struct LDKDelayedPaymentKey broadcaster_delayed_payment_key_arg);
41635 export function TxCreationKeys_new(per_commitment_point_arg: number, revocation_key_arg: bigint, broadcaster_htlc_key_arg: bigint, countersignatory_htlc_key_arg: bigint, broadcaster_delayed_payment_key_arg: bigint): bigint {
41636 if(!isWasmInitialized) {
41637 throw new Error("initializeWasm() must be awaited first!");
41639 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);
41640 return nativeResponseValue;
41642 // bool TxCreationKeys_eq(const struct LDKTxCreationKeys *NONNULL_PTR a, const struct LDKTxCreationKeys *NONNULL_PTR b);
41644 export function TxCreationKeys_eq(a: bigint, b: bigint): boolean {
41645 if(!isWasmInitialized) {
41646 throw new Error("initializeWasm() must be awaited first!");
41648 const nativeResponseValue = wasm.TS_TxCreationKeys_eq(a, b);
41649 return nativeResponseValue;
41651 // uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
41653 export function TxCreationKeys_clone_ptr(arg: bigint): bigint {
41654 if(!isWasmInitialized) {
41655 throw new Error("initializeWasm() must be awaited first!");
41657 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
41658 return nativeResponseValue;
41660 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
41662 export function TxCreationKeys_clone(orig: bigint): bigint {
41663 if(!isWasmInitialized) {
41664 throw new Error("initializeWasm() must be awaited first!");
41666 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
41667 return nativeResponseValue;
41669 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
41671 export function TxCreationKeys_write(obj: bigint): number {
41672 if(!isWasmInitialized) {
41673 throw new Error("initializeWasm() must be awaited first!");
41675 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
41676 return nativeResponseValue;
41678 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
41680 export function TxCreationKeys_read(ser: number): bigint {
41681 if(!isWasmInitialized) {
41682 throw new Error("initializeWasm() must be awaited first!");
41684 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
41685 return nativeResponseValue;
41687 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
41689 export function ChannelPublicKeys_free(this_obj: bigint): void {
41690 if(!isWasmInitialized) {
41691 throw new Error("initializeWasm() must be awaited first!");
41693 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
41694 // debug statements here
41696 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
41698 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: bigint): number {
41699 if(!isWasmInitialized) {
41700 throw new Error("initializeWasm() must be awaited first!");
41702 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
41703 return nativeResponseValue;
41705 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
41707 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: bigint, val: number): void {
41708 if(!isWasmInitialized) {
41709 throw new Error("initializeWasm() must be awaited first!");
41711 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
41712 // debug statements here
41714 // struct LDKRevocationBasepoint ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
41716 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: bigint): bigint {
41717 if(!isWasmInitialized) {
41718 throw new Error("initializeWasm() must be awaited first!");
41720 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
41721 return nativeResponseValue;
41723 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKRevocationBasepoint val);
41725 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: bigint, val: bigint): void {
41726 if(!isWasmInitialized) {
41727 throw new Error("initializeWasm() must be awaited first!");
41729 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
41730 // debug statements here
41732 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
41734 export function ChannelPublicKeys_get_payment_point(this_ptr: bigint): number {
41735 if(!isWasmInitialized) {
41736 throw new Error("initializeWasm() must be awaited first!");
41738 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
41739 return nativeResponseValue;
41741 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
41743 export function ChannelPublicKeys_set_payment_point(this_ptr: bigint, val: number): void {
41744 if(!isWasmInitialized) {
41745 throw new Error("initializeWasm() must be awaited first!");
41747 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
41748 // debug statements here
41750 // struct LDKDelayedPaymentBasepoint ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
41752 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: bigint): bigint {
41753 if(!isWasmInitialized) {
41754 throw new Error("initializeWasm() must be awaited first!");
41756 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
41757 return nativeResponseValue;
41759 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKDelayedPaymentBasepoint val);
41761 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: bigint, val: bigint): void {
41762 if(!isWasmInitialized) {
41763 throw new Error("initializeWasm() must be awaited first!");
41765 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
41766 // debug statements here
41768 // struct LDKHtlcBasepoint ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
41770 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: bigint): bigint {
41771 if(!isWasmInitialized) {
41772 throw new Error("initializeWasm() must be awaited first!");
41774 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
41775 return nativeResponseValue;
41777 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKHtlcBasepoint val);
41779 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: bigint, val: bigint): void {
41780 if(!isWasmInitialized) {
41781 throw new Error("initializeWasm() must be awaited first!");
41783 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
41784 // debug statements here
41786 // MUST_USE_RES struct LDKChannelPublicKeys ChannelPublicKeys_new(struct LDKPublicKey funding_pubkey_arg, struct LDKRevocationBasepoint revocation_basepoint_arg, struct LDKPublicKey payment_point_arg, struct LDKDelayedPaymentBasepoint delayed_payment_basepoint_arg, struct LDKHtlcBasepoint htlc_basepoint_arg);
41788 export function ChannelPublicKeys_new(funding_pubkey_arg: number, revocation_basepoint_arg: bigint, payment_point_arg: number, delayed_payment_basepoint_arg: bigint, htlc_basepoint_arg: bigint): bigint {
41789 if(!isWasmInitialized) {
41790 throw new Error("initializeWasm() must be awaited first!");
41792 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
41793 return nativeResponseValue;
41795 // uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
41797 export function ChannelPublicKeys_clone_ptr(arg: bigint): bigint {
41798 if(!isWasmInitialized) {
41799 throw new Error("initializeWasm() must be awaited first!");
41801 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
41802 return nativeResponseValue;
41804 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
41806 export function ChannelPublicKeys_clone(orig: bigint): bigint {
41807 if(!isWasmInitialized) {
41808 throw new Error("initializeWasm() must be awaited first!");
41810 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
41811 return nativeResponseValue;
41813 // uint64_t ChannelPublicKeys_hash(const struct LDKChannelPublicKeys *NONNULL_PTR o);
41815 export function ChannelPublicKeys_hash(o: bigint): bigint {
41816 if(!isWasmInitialized) {
41817 throw new Error("initializeWasm() must be awaited first!");
41819 const nativeResponseValue = wasm.TS_ChannelPublicKeys_hash(o);
41820 return nativeResponseValue;
41822 // bool ChannelPublicKeys_eq(const struct LDKChannelPublicKeys *NONNULL_PTR a, const struct LDKChannelPublicKeys *NONNULL_PTR b);
41824 export function ChannelPublicKeys_eq(a: bigint, b: bigint): boolean {
41825 if(!isWasmInitialized) {
41826 throw new Error("initializeWasm() must be awaited first!");
41828 const nativeResponseValue = wasm.TS_ChannelPublicKeys_eq(a, b);
41829 return nativeResponseValue;
41831 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
41833 export function ChannelPublicKeys_write(obj: bigint): number {
41834 if(!isWasmInitialized) {
41835 throw new Error("initializeWasm() must be awaited first!");
41837 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
41838 return nativeResponseValue;
41840 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
41842 export function ChannelPublicKeys_read(ser: number): bigint {
41843 if(!isWasmInitialized) {
41844 throw new Error("initializeWasm() must be awaited first!");
41846 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
41847 return nativeResponseValue;
41849 // MUST_USE_RES struct LDKTxCreationKeys TxCreationKeys_derive_new(struct LDKPublicKey per_commitment_point, const struct LDKDelayedPaymentBasepoint *NONNULL_PTR broadcaster_delayed_payment_base, const struct LDKHtlcBasepoint *NONNULL_PTR broadcaster_htlc_base, const struct LDKRevocationBasepoint *NONNULL_PTR countersignatory_revocation_base, const struct LDKHtlcBasepoint *NONNULL_PTR countersignatory_htlc_base);
41851 export function TxCreationKeys_derive_new(per_commitment_point: number, broadcaster_delayed_payment_base: bigint, broadcaster_htlc_base: bigint, countersignatory_revocation_base: bigint, countersignatory_htlc_base: bigint): bigint {
41852 if(!isWasmInitialized) {
41853 throw new Error("initializeWasm() must be awaited first!");
41855 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
41856 return nativeResponseValue;
41858 // 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);
41860 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
41861 if(!isWasmInitialized) {
41862 throw new Error("initializeWasm() must be awaited first!");
41864 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
41865 return nativeResponseValue;
41867 // struct LDKCVec_u8Z get_revokeable_redeemscript(const struct LDKRevocationKey *NONNULL_PTR revocation_key, uint16_t contest_delay, const struct LDKDelayedPaymentKey *NONNULL_PTR broadcaster_delayed_payment_key);
41869 export function get_revokeable_redeemscript(revocation_key: bigint, contest_delay: number, broadcaster_delayed_payment_key: bigint): number {
41870 if(!isWasmInitialized) {
41871 throw new Error("initializeWasm() must be awaited first!");
41873 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
41874 return nativeResponseValue;
41876 // struct LDKCVec_u8Z get_counterparty_payment_script(const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features, struct LDKPublicKey payment_key);
41878 export function get_counterparty_payment_script(channel_type_features: bigint, payment_key: number): number {
41879 if(!isWasmInitialized) {
41880 throw new Error("initializeWasm() must be awaited first!");
41882 const nativeResponseValue = wasm.TS_get_counterparty_payment_script(channel_type_features, payment_key);
41883 return nativeResponseValue;
41885 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
41887 export function HTLCOutputInCommitment_free(this_obj: bigint): void {
41888 if(!isWasmInitialized) {
41889 throw new Error("initializeWasm() must be awaited first!");
41891 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
41892 // debug statements here
41894 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
41896 export function HTLCOutputInCommitment_get_offered(this_ptr: bigint): boolean {
41897 if(!isWasmInitialized) {
41898 throw new Error("initializeWasm() must be awaited first!");
41900 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
41901 return nativeResponseValue;
41903 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
41905 export function HTLCOutputInCommitment_set_offered(this_ptr: bigint, val: boolean): void {
41906 if(!isWasmInitialized) {
41907 throw new Error("initializeWasm() must be awaited first!");
41909 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
41910 // debug statements here
41912 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
41914 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: bigint): bigint {
41915 if(!isWasmInitialized) {
41916 throw new Error("initializeWasm() must be awaited first!");
41918 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
41919 return nativeResponseValue;
41921 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
41923 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: bigint, val: bigint): void {
41924 if(!isWasmInitialized) {
41925 throw new Error("initializeWasm() must be awaited first!");
41927 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
41928 // debug statements here
41930 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
41932 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: bigint): number {
41933 if(!isWasmInitialized) {
41934 throw new Error("initializeWasm() must be awaited first!");
41936 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
41937 return nativeResponseValue;
41939 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
41941 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: bigint, val: number): void {
41942 if(!isWasmInitialized) {
41943 throw new Error("initializeWasm() must be awaited first!");
41945 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
41946 // debug statements here
41948 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
41950 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: bigint): number {
41951 if(!isWasmInitialized) {
41952 throw new Error("initializeWasm() must be awaited first!");
41954 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
41955 return nativeResponseValue;
41957 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
41959 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: bigint, val: number): void {
41960 if(!isWasmInitialized) {
41961 throw new Error("initializeWasm() must be awaited first!");
41963 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
41964 // debug statements here
41966 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
41968 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: bigint): bigint {
41969 if(!isWasmInitialized) {
41970 throw new Error("initializeWasm() must be awaited first!");
41972 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
41973 return nativeResponseValue;
41975 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
41977 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: bigint, val: bigint): void {
41978 if(!isWasmInitialized) {
41979 throw new Error("initializeWasm() must be awaited first!");
41981 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
41982 // debug statements here
41984 // 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);
41986 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 {
41987 if(!isWasmInitialized) {
41988 throw new Error("initializeWasm() must be awaited first!");
41990 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
41991 return nativeResponseValue;
41993 // uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
41995 export function HTLCOutputInCommitment_clone_ptr(arg: bigint): bigint {
41996 if(!isWasmInitialized) {
41997 throw new Error("initializeWasm() must be awaited first!");
41999 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
42000 return nativeResponseValue;
42002 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
42004 export function HTLCOutputInCommitment_clone(orig: bigint): bigint {
42005 if(!isWasmInitialized) {
42006 throw new Error("initializeWasm() must be awaited first!");
42008 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
42009 return nativeResponseValue;
42011 // bool HTLCOutputInCommitment_eq(const struct LDKHTLCOutputInCommitment *NONNULL_PTR a, const struct LDKHTLCOutputInCommitment *NONNULL_PTR b);
42013 export function HTLCOutputInCommitment_eq(a: bigint, b: bigint): boolean {
42014 if(!isWasmInitialized) {
42015 throw new Error("initializeWasm() must be awaited first!");
42017 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_eq(a, b);
42018 return nativeResponseValue;
42020 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
42022 export function HTLCOutputInCommitment_write(obj: bigint): number {
42023 if(!isWasmInitialized) {
42024 throw new Error("initializeWasm() must be awaited first!");
42026 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
42027 return nativeResponseValue;
42029 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
42031 export function HTLCOutputInCommitment_read(ser: number): bigint {
42032 if(!isWasmInitialized) {
42033 throw new Error("initializeWasm() must be awaited first!");
42035 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
42036 return nativeResponseValue;
42038 // 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);
42040 export function get_htlc_redeemscript(htlc: bigint, channel_type_features: bigint, keys: bigint): number {
42041 if(!isWasmInitialized) {
42042 throw new Error("initializeWasm() must be awaited first!");
42044 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, channel_type_features, keys);
42045 return nativeResponseValue;
42047 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
42049 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
42050 if(!isWasmInitialized) {
42051 throw new Error("initializeWasm() must be awaited first!");
42053 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
42054 return nativeResponseValue;
42056 // struct LDKTransaction build_htlc_transaction(const uint8_t (*commitment_txid)[32], uint32_t feerate_per_kw, uint16_t contest_delay, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, const struct LDKChannelTypeFeatures *NONNULL_PTR channel_type_features, const struct LDKDelayedPaymentKey *NONNULL_PTR broadcaster_delayed_payment_key, const struct LDKRevocationKey *NONNULL_PTR revocation_key);
42058 export function build_htlc_transaction(commitment_txid: number, feerate_per_kw: number, contest_delay: number, htlc: bigint, channel_type_features: bigint, broadcaster_delayed_payment_key: bigint, revocation_key: bigint): number {
42059 if(!isWasmInitialized) {
42060 throw new Error("initializeWasm() must be awaited first!");
42062 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, channel_type_features, broadcaster_delayed_payment_key, revocation_key);
42063 return nativeResponseValue;
42065 // 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);
42067 export function build_htlc_input_witness(local_sig: number, remote_sig: number, preimage: bigint, redeem_script: number, channel_type_features: bigint): number {
42068 if(!isWasmInitialized) {
42069 throw new Error("initializeWasm() must be awaited first!");
42071 const nativeResponseValue = wasm.TS_build_htlc_input_witness(local_sig, remote_sig, preimage, redeem_script, channel_type_features);
42072 return nativeResponseValue;
42074 // struct LDKCVec_u8Z get_to_countersignatory_with_anchors_redeemscript(struct LDKPublicKey payment_point);
42076 export function get_to_countersignatory_with_anchors_redeemscript(payment_point: number): number {
42077 if(!isWasmInitialized) {
42078 throw new Error("initializeWasm() must be awaited first!");
42080 const nativeResponseValue = wasm.TS_get_to_countersignatory_with_anchors_redeemscript(payment_point);
42081 return nativeResponseValue;
42083 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
42085 export function get_anchor_redeemscript(funding_pubkey: number): number {
42086 if(!isWasmInitialized) {
42087 throw new Error("initializeWasm() must be awaited first!");
42089 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
42090 return nativeResponseValue;
42092 // struct LDKWitness build_anchor_input_witness(struct LDKPublicKey funding_key, struct LDKECDSASignature funding_sig);
42094 export function build_anchor_input_witness(funding_key: number, funding_sig: number): number {
42095 if(!isWasmInitialized) {
42096 throw new Error("initializeWasm() must be awaited first!");
42098 const nativeResponseValue = wasm.TS_build_anchor_input_witness(funding_key, funding_sig);
42099 return nativeResponseValue;
42101 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
42103 export function ChannelTransactionParameters_free(this_obj: bigint): void {
42104 if(!isWasmInitialized) {
42105 throw new Error("initializeWasm() must be awaited first!");
42107 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
42108 // debug statements here
42110 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
42112 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: bigint): bigint {
42113 if(!isWasmInitialized) {
42114 throw new Error("initializeWasm() must be awaited first!");
42116 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
42117 return nativeResponseValue;
42119 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
42121 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: bigint, val: bigint): void {
42122 if(!isWasmInitialized) {
42123 throw new Error("initializeWasm() must be awaited first!");
42125 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
42126 // debug statements here
42128 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
42130 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: bigint): number {
42131 if(!isWasmInitialized) {
42132 throw new Error("initializeWasm() must be awaited first!");
42134 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
42135 return nativeResponseValue;
42137 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
42139 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: bigint, val: number): void {
42140 if(!isWasmInitialized) {
42141 throw new Error("initializeWasm() must be awaited first!");
42143 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
42144 // debug statements here
42146 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
42148 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: bigint): boolean {
42149 if(!isWasmInitialized) {
42150 throw new Error("initializeWasm() must be awaited first!");
42152 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
42153 return nativeResponseValue;
42155 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
42157 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: bigint, val: boolean): void {
42158 if(!isWasmInitialized) {
42159 throw new Error("initializeWasm() must be awaited first!");
42161 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
42162 // debug statements here
42164 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
42166 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: bigint): bigint {
42167 if(!isWasmInitialized) {
42168 throw new Error("initializeWasm() must be awaited first!");
42170 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
42171 return nativeResponseValue;
42173 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
42175 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: bigint, val: bigint): void {
42176 if(!isWasmInitialized) {
42177 throw new Error("initializeWasm() must be awaited first!");
42179 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
42180 // debug statements here
42182 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
42184 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: bigint): bigint {
42185 if(!isWasmInitialized) {
42186 throw new Error("initializeWasm() must be awaited first!");
42188 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
42189 return nativeResponseValue;
42191 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
42193 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: bigint, val: bigint): void {
42194 if(!isWasmInitialized) {
42195 throw new Error("initializeWasm() must be awaited first!");
42197 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
42198 // debug statements here
42200 // struct LDKChannelTypeFeatures ChannelTransactionParameters_get_channel_type_features(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
42202 export function ChannelTransactionParameters_get_channel_type_features(this_ptr: bigint): bigint {
42203 if(!isWasmInitialized) {
42204 throw new Error("initializeWasm() must be awaited first!");
42206 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_channel_type_features(this_ptr);
42207 return nativeResponseValue;
42209 // void ChannelTransactionParameters_set_channel_type_features(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
42211 export function ChannelTransactionParameters_set_channel_type_features(this_ptr: bigint, val: bigint): void {
42212 if(!isWasmInitialized) {
42213 throw new Error("initializeWasm() must be awaited first!");
42215 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_channel_type_features(this_ptr, val);
42216 // debug statements here
42218 // 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);
42220 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 {
42221 if(!isWasmInitialized) {
42222 throw new Error("initializeWasm() must be awaited first!");
42224 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);
42225 return nativeResponseValue;
42227 // uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
42229 export function ChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
42230 if(!isWasmInitialized) {
42231 throw new Error("initializeWasm() must be awaited first!");
42233 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
42234 return nativeResponseValue;
42236 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
42238 export function ChannelTransactionParameters_clone(orig: bigint): bigint {
42239 if(!isWasmInitialized) {
42240 throw new Error("initializeWasm() must be awaited first!");
42242 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
42243 return nativeResponseValue;
42245 // uint64_t ChannelTransactionParameters_hash(const struct LDKChannelTransactionParameters *NONNULL_PTR o);
42247 export function ChannelTransactionParameters_hash(o: bigint): bigint {
42248 if(!isWasmInitialized) {
42249 throw new Error("initializeWasm() must be awaited first!");
42251 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_hash(o);
42252 return nativeResponseValue;
42254 // bool ChannelTransactionParameters_eq(const struct LDKChannelTransactionParameters *NONNULL_PTR a, const struct LDKChannelTransactionParameters *NONNULL_PTR b);
42256 export function ChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
42257 if(!isWasmInitialized) {
42258 throw new Error("initializeWasm() must be awaited first!");
42260 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_eq(a, b);
42261 return nativeResponseValue;
42263 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
42265 export function CounterpartyChannelTransactionParameters_free(this_obj: bigint): void {
42266 if(!isWasmInitialized) {
42267 throw new Error("initializeWasm() must be awaited first!");
42269 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
42270 // debug statements here
42272 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
42274 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: bigint): bigint {
42275 if(!isWasmInitialized) {
42276 throw new Error("initializeWasm() must be awaited first!");
42278 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
42279 return nativeResponseValue;
42281 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
42283 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: bigint, val: bigint): void {
42284 if(!isWasmInitialized) {
42285 throw new Error("initializeWasm() must be awaited first!");
42287 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
42288 // debug statements here
42290 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
42292 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: bigint): number {
42293 if(!isWasmInitialized) {
42294 throw new Error("initializeWasm() must be awaited first!");
42296 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
42297 return nativeResponseValue;
42299 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
42301 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: bigint, val: number): void {
42302 if(!isWasmInitialized) {
42303 throw new Error("initializeWasm() must be awaited first!");
42305 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
42306 // debug statements here
42308 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
42310 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: bigint, selected_contest_delay_arg: number): bigint {
42311 if(!isWasmInitialized) {
42312 throw new Error("initializeWasm() must be awaited first!");
42314 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
42315 return nativeResponseValue;
42317 // uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
42319 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: bigint): bigint {
42320 if(!isWasmInitialized) {
42321 throw new Error("initializeWasm() must be awaited first!");
42323 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
42324 return nativeResponseValue;
42326 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
42328 export function CounterpartyChannelTransactionParameters_clone(orig: bigint): bigint {
42329 if(!isWasmInitialized) {
42330 throw new Error("initializeWasm() must be awaited first!");
42332 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
42333 return nativeResponseValue;
42335 // uint64_t CounterpartyChannelTransactionParameters_hash(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR o);
42337 export function CounterpartyChannelTransactionParameters_hash(o: bigint): bigint {
42338 if(!isWasmInitialized) {
42339 throw new Error("initializeWasm() must be awaited first!");
42341 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_hash(o);
42342 return nativeResponseValue;
42344 // bool CounterpartyChannelTransactionParameters_eq(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR a, const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR b);
42346 export function CounterpartyChannelTransactionParameters_eq(a: bigint, b: bigint): boolean {
42347 if(!isWasmInitialized) {
42348 throw new Error("initializeWasm() must be awaited first!");
42350 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_eq(a, b);
42351 return nativeResponseValue;
42353 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
42355 export function ChannelTransactionParameters_is_populated(this_arg: bigint): boolean {
42356 if(!isWasmInitialized) {
42357 throw new Error("initializeWasm() must be awaited first!");
42359 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
42360 return nativeResponseValue;
42362 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
42364 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: bigint): bigint {
42365 if(!isWasmInitialized) {
42366 throw new Error("initializeWasm() must be awaited first!");
42368 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
42369 return nativeResponseValue;
42371 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
42373 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: bigint): bigint {
42374 if(!isWasmInitialized) {
42375 throw new Error("initializeWasm() must be awaited first!");
42377 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
42378 return nativeResponseValue;
42380 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
42382 export function CounterpartyChannelTransactionParameters_write(obj: bigint): number {
42383 if(!isWasmInitialized) {
42384 throw new Error("initializeWasm() must be awaited first!");
42386 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
42387 return nativeResponseValue;
42389 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
42391 export function CounterpartyChannelTransactionParameters_read(ser: number): bigint {
42392 if(!isWasmInitialized) {
42393 throw new Error("initializeWasm() must be awaited first!");
42395 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
42396 return nativeResponseValue;
42398 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
42400 export function ChannelTransactionParameters_write(obj: bigint): number {
42401 if(!isWasmInitialized) {
42402 throw new Error("initializeWasm() must be awaited first!");
42404 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
42405 return nativeResponseValue;
42407 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
42409 export function ChannelTransactionParameters_read(ser: number): bigint {
42410 if(!isWasmInitialized) {
42411 throw new Error("initializeWasm() must be awaited first!");
42413 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
42414 return nativeResponseValue;
42416 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
42418 export function DirectedChannelTransactionParameters_free(this_obj: bigint): void {
42419 if(!isWasmInitialized) {
42420 throw new Error("initializeWasm() must be awaited first!");
42422 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
42423 // debug statements here
42425 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
42427 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: bigint): bigint {
42428 if(!isWasmInitialized) {
42429 throw new Error("initializeWasm() must be awaited first!");
42431 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
42432 return nativeResponseValue;
42434 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
42436 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: bigint): bigint {
42437 if(!isWasmInitialized) {
42438 throw new Error("initializeWasm() must be awaited first!");
42440 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
42441 return nativeResponseValue;
42443 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
42445 export function DirectedChannelTransactionParameters_contest_delay(this_arg: bigint): number {
42446 if(!isWasmInitialized) {
42447 throw new Error("initializeWasm() must be awaited first!");
42449 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
42450 return nativeResponseValue;
42452 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
42454 export function DirectedChannelTransactionParameters_is_outbound(this_arg: bigint): boolean {
42455 if(!isWasmInitialized) {
42456 throw new Error("initializeWasm() must be awaited first!");
42458 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
42459 return nativeResponseValue;
42461 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
42463 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: bigint): bigint {
42464 if(!isWasmInitialized) {
42465 throw new Error("initializeWasm() must be awaited first!");
42467 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
42468 return nativeResponseValue;
42470 // MUST_USE_RES struct LDKChannelTypeFeatures DirectedChannelTransactionParameters_channel_type_features(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
42472 export function DirectedChannelTransactionParameters_channel_type_features(this_arg: bigint): bigint {
42473 if(!isWasmInitialized) {
42474 throw new Error("initializeWasm() must be awaited first!");
42476 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_channel_type_features(this_arg);
42477 return nativeResponseValue;
42479 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
42481 export function HolderCommitmentTransaction_free(this_obj: bigint): void {
42482 if(!isWasmInitialized) {
42483 throw new Error("initializeWasm() must be awaited first!");
42485 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
42486 // debug statements here
42488 // struct LDKECDSASignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
42490 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: bigint): number {
42491 if(!isWasmInitialized) {
42492 throw new Error("initializeWasm() must be awaited first!");
42494 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
42495 return nativeResponseValue;
42497 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
42499 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: bigint, val: number): void {
42500 if(!isWasmInitialized) {
42501 throw new Error("initializeWasm() must be awaited first!");
42503 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
42504 // debug statements here
42506 // struct LDKCVec_ECDSASignatureZ HolderCommitmentTransaction_get_counterparty_htlc_sigs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
42508 export function HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr: bigint): number {
42509 if(!isWasmInitialized) {
42510 throw new Error("initializeWasm() must be awaited first!");
42512 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(this_ptr);
42513 return nativeResponseValue;
42515 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_ECDSASignatureZ val);
42517 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: bigint, val: number): void {
42518 if(!isWasmInitialized) {
42519 throw new Error("initializeWasm() must be awaited first!");
42521 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
42522 // debug statements here
42524 // uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
42526 export function HolderCommitmentTransaction_clone_ptr(arg: bigint): bigint {
42527 if(!isWasmInitialized) {
42528 throw new Error("initializeWasm() must be awaited first!");
42530 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
42531 return nativeResponseValue;
42533 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
42535 export function HolderCommitmentTransaction_clone(orig: bigint): bigint {
42536 if(!isWasmInitialized) {
42537 throw new Error("initializeWasm() must be awaited first!");
42539 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
42540 return nativeResponseValue;
42542 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
42544 export function HolderCommitmentTransaction_write(obj: bigint): number {
42545 if(!isWasmInitialized) {
42546 throw new Error("initializeWasm() must be awaited first!");
42548 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
42549 return nativeResponseValue;
42551 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
42553 export function HolderCommitmentTransaction_read(ser: number): bigint {
42554 if(!isWasmInitialized) {
42555 throw new Error("initializeWasm() must be awaited first!");
42557 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
42558 return nativeResponseValue;
42560 // 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);
42562 export function HolderCommitmentTransaction_new(commitment_tx: bigint, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): bigint {
42563 if(!isWasmInitialized) {
42564 throw new Error("initializeWasm() must be awaited first!");
42566 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
42567 return nativeResponseValue;
42569 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
42571 export function BuiltCommitmentTransaction_free(this_obj: bigint): void {
42572 if(!isWasmInitialized) {
42573 throw new Error("initializeWasm() must be awaited first!");
42575 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
42576 // debug statements here
42578 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
42580 export function BuiltCommitmentTransaction_get_transaction(this_ptr: bigint): number {
42581 if(!isWasmInitialized) {
42582 throw new Error("initializeWasm() must be awaited first!");
42584 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
42585 return nativeResponseValue;
42587 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
42589 export function BuiltCommitmentTransaction_set_transaction(this_ptr: bigint, val: number): void {
42590 if(!isWasmInitialized) {
42591 throw new Error("initializeWasm() must be awaited first!");
42593 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
42594 // debug statements here
42596 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
42598 export function BuiltCommitmentTransaction_get_txid(this_ptr: bigint): number {
42599 if(!isWasmInitialized) {
42600 throw new Error("initializeWasm() must be awaited first!");
42602 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
42603 return nativeResponseValue;
42605 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
42607 export function BuiltCommitmentTransaction_set_txid(this_ptr: bigint, val: number): void {
42608 if(!isWasmInitialized) {
42609 throw new Error("initializeWasm() must be awaited first!");
42611 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
42612 // debug statements here
42614 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
42616 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): bigint {
42617 if(!isWasmInitialized) {
42618 throw new Error("initializeWasm() must be awaited first!");
42620 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
42621 return nativeResponseValue;
42623 // uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
42625 export function BuiltCommitmentTransaction_clone_ptr(arg: bigint): bigint {
42626 if(!isWasmInitialized) {
42627 throw new Error("initializeWasm() must be awaited first!");
42629 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
42630 return nativeResponseValue;
42632 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
42634 export function BuiltCommitmentTransaction_clone(orig: bigint): bigint {
42635 if(!isWasmInitialized) {
42636 throw new Error("initializeWasm() must be awaited first!");
42638 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
42639 return nativeResponseValue;
42641 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
42643 export function BuiltCommitmentTransaction_write(obj: bigint): number {
42644 if(!isWasmInitialized) {
42645 throw new Error("initializeWasm() must be awaited first!");
42647 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
42648 return nativeResponseValue;
42650 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
42652 export function BuiltCommitmentTransaction_read(ser: number): bigint {
42653 if(!isWasmInitialized) {
42654 throw new Error("initializeWasm() must be awaited first!");
42656 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
42657 return nativeResponseValue;
42659 // 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);
42661 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
42662 if(!isWasmInitialized) {
42663 throw new Error("initializeWasm() must be awaited first!");
42665 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
42666 return nativeResponseValue;
42668 // 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);
42670 export function BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
42671 if(!isWasmInitialized) {
42672 throw new Error("initializeWasm() must be awaited first!");
42674 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_counterparty_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
42675 return nativeResponseValue;
42677 // 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);
42679 export function BuiltCommitmentTransaction_sign_holder_commitment(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint, entropy_source: bigint): number {
42680 if(!isWasmInitialized) {
42681 throw new Error("initializeWasm() must be awaited first!");
42683 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign_holder_commitment(this_arg, funding_key, funding_redeemscript, channel_value_satoshis, entropy_source);
42684 return nativeResponseValue;
42686 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
42688 export function ClosingTransaction_free(this_obj: bigint): void {
42689 if(!isWasmInitialized) {
42690 throw new Error("initializeWasm() must be awaited first!");
42692 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
42693 // debug statements here
42695 // uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
42697 export function ClosingTransaction_clone_ptr(arg: bigint): bigint {
42698 if(!isWasmInitialized) {
42699 throw new Error("initializeWasm() must be awaited first!");
42701 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
42702 return nativeResponseValue;
42704 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
42706 export function ClosingTransaction_clone(orig: bigint): bigint {
42707 if(!isWasmInitialized) {
42708 throw new Error("initializeWasm() must be awaited first!");
42710 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
42711 return nativeResponseValue;
42713 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
42715 export function ClosingTransaction_hash(o: bigint): bigint {
42716 if(!isWasmInitialized) {
42717 throw new Error("initializeWasm() must be awaited first!");
42719 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
42720 return nativeResponseValue;
42722 // bool ClosingTransaction_eq(const struct LDKClosingTransaction *NONNULL_PTR a, const struct LDKClosingTransaction *NONNULL_PTR b);
42724 export function ClosingTransaction_eq(a: bigint, b: bigint): boolean {
42725 if(!isWasmInitialized) {
42726 throw new Error("initializeWasm() must be awaited first!");
42728 const nativeResponseValue = wasm.TS_ClosingTransaction_eq(a, b);
42729 return nativeResponseValue;
42731 // 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);
42733 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 {
42734 if(!isWasmInitialized) {
42735 throw new Error("initializeWasm() must be awaited first!");
42737 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
42738 return nativeResponseValue;
42740 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
42742 export function ClosingTransaction_trust(this_arg: bigint): bigint {
42743 if(!isWasmInitialized) {
42744 throw new Error("initializeWasm() must be awaited first!");
42746 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
42747 return nativeResponseValue;
42749 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
42751 export function ClosingTransaction_verify(this_arg: bigint, funding_outpoint: bigint): bigint {
42752 if(!isWasmInitialized) {
42753 throw new Error("initializeWasm() must be awaited first!");
42755 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
42756 return nativeResponseValue;
42758 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
42760 export function ClosingTransaction_to_holder_value_sat(this_arg: bigint): bigint {
42761 if(!isWasmInitialized) {
42762 throw new Error("initializeWasm() must be awaited first!");
42764 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
42765 return nativeResponseValue;
42767 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
42769 export function ClosingTransaction_to_counterparty_value_sat(this_arg: bigint): bigint {
42770 if(!isWasmInitialized) {
42771 throw new Error("initializeWasm() must be awaited first!");
42773 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
42774 return nativeResponseValue;
42776 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
42778 export function ClosingTransaction_to_holder_script(this_arg: bigint): number {
42779 if(!isWasmInitialized) {
42780 throw new Error("initializeWasm() must be awaited first!");
42782 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
42783 return nativeResponseValue;
42785 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
42787 export function ClosingTransaction_to_counterparty_script(this_arg: bigint): number {
42788 if(!isWasmInitialized) {
42789 throw new Error("initializeWasm() must be awaited first!");
42791 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
42792 return nativeResponseValue;
42794 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
42796 export function TrustedClosingTransaction_free(this_obj: bigint): void {
42797 if(!isWasmInitialized) {
42798 throw new Error("initializeWasm() must be awaited first!");
42800 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
42801 // debug statements here
42803 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
42805 export function TrustedClosingTransaction_built_transaction(this_arg: bigint): number {
42806 if(!isWasmInitialized) {
42807 throw new Error("initializeWasm() must be awaited first!");
42809 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
42810 return nativeResponseValue;
42812 // 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);
42814 export function TrustedClosingTransaction_get_sighash_all(this_arg: bigint, funding_redeemscript: number, channel_value_satoshis: bigint): number {
42815 if(!isWasmInitialized) {
42816 throw new Error("initializeWasm() must be awaited first!");
42818 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
42819 return nativeResponseValue;
42821 // 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);
42823 export function TrustedClosingTransaction_sign(this_arg: bigint, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
42824 if(!isWasmInitialized) {
42825 throw new Error("initializeWasm() must be awaited first!");
42827 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
42828 return nativeResponseValue;
42830 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
42832 export function CommitmentTransaction_free(this_obj: bigint): void {
42833 if(!isWasmInitialized) {
42834 throw new Error("initializeWasm() must be awaited first!");
42836 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
42837 // debug statements here
42839 // uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
42841 export function CommitmentTransaction_clone_ptr(arg: bigint): bigint {
42842 if(!isWasmInitialized) {
42843 throw new Error("initializeWasm() must be awaited first!");
42845 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
42846 return nativeResponseValue;
42848 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
42850 export function CommitmentTransaction_clone(orig: bigint): bigint {
42851 if(!isWasmInitialized) {
42852 throw new Error("initializeWasm() must be awaited first!");
42854 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
42855 return nativeResponseValue;
42857 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
42859 export function CommitmentTransaction_write(obj: bigint): number {
42860 if(!isWasmInitialized) {
42861 throw new Error("initializeWasm() must be awaited first!");
42863 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
42864 return nativeResponseValue;
42866 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
42868 export function CommitmentTransaction_read(ser: number): bigint {
42869 if(!isWasmInitialized) {
42870 throw new Error("initializeWasm() must be awaited first!");
42872 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
42873 return nativeResponseValue;
42875 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
42877 export function CommitmentTransaction_commitment_number(this_arg: bigint): bigint {
42878 if(!isWasmInitialized) {
42879 throw new Error("initializeWasm() must be awaited first!");
42881 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
42882 return nativeResponseValue;
42884 // MUST_USE_RES struct LDKPublicKey CommitmentTransaction_per_commitment_point(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
42886 export function CommitmentTransaction_per_commitment_point(this_arg: bigint): number {
42887 if(!isWasmInitialized) {
42888 throw new Error("initializeWasm() must be awaited first!");
42890 const nativeResponseValue = wasm.TS_CommitmentTransaction_per_commitment_point(this_arg);
42891 return nativeResponseValue;
42893 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
42895 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: bigint): bigint {
42896 if(!isWasmInitialized) {
42897 throw new Error("initializeWasm() must be awaited first!");
42899 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
42900 return nativeResponseValue;
42902 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
42904 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: bigint): bigint {
42905 if(!isWasmInitialized) {
42906 throw new Error("initializeWasm() must be awaited first!");
42908 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
42909 return nativeResponseValue;
42911 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
42913 export function CommitmentTransaction_feerate_per_kw(this_arg: bigint): number {
42914 if(!isWasmInitialized) {
42915 throw new Error("initializeWasm() must be awaited first!");
42917 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
42918 return nativeResponseValue;
42920 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
42922 export function CommitmentTransaction_trust(this_arg: bigint): bigint {
42923 if(!isWasmInitialized) {
42924 throw new Error("initializeWasm() must be awaited first!");
42926 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
42927 return nativeResponseValue;
42929 // 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);
42931 export function CommitmentTransaction_verify(this_arg: bigint, channel_parameters: bigint, broadcaster_keys: bigint, countersignatory_keys: bigint): bigint {
42932 if(!isWasmInitialized) {
42933 throw new Error("initializeWasm() must be awaited first!");
42935 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
42936 return nativeResponseValue;
42938 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
42940 export function TrustedCommitmentTransaction_free(this_obj: bigint): void {
42941 if(!isWasmInitialized) {
42942 throw new Error("initializeWasm() must be awaited first!");
42944 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
42945 // debug statements here
42947 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
42949 export function TrustedCommitmentTransaction_txid(this_arg: bigint): number {
42950 if(!isWasmInitialized) {
42951 throw new Error("initializeWasm() must be awaited first!");
42953 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
42954 return nativeResponseValue;
42956 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
42958 export function TrustedCommitmentTransaction_built_transaction(this_arg: bigint): bigint {
42959 if(!isWasmInitialized) {
42960 throw new Error("initializeWasm() must be awaited first!");
42962 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
42963 return nativeResponseValue;
42965 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
42967 export function TrustedCommitmentTransaction_keys(this_arg: bigint): bigint {
42968 if(!isWasmInitialized) {
42969 throw new Error("initializeWasm() must be awaited first!");
42971 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
42972 return nativeResponseValue;
42974 // MUST_USE_RES struct LDKChannelTypeFeatures TrustedCommitmentTransaction_channel_type_features(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
42976 export function TrustedCommitmentTransaction_channel_type_features(this_arg: bigint): bigint {
42977 if(!isWasmInitialized) {
42978 throw new Error("initializeWasm() must be awaited first!");
42980 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_channel_type_features(this_arg);
42981 return nativeResponseValue;
42983 // 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);
42985 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: bigint, htlc_base_key: number, channel_parameters: bigint, entropy_source: bigint): bigint {
42986 if(!isWasmInitialized) {
42987 throw new Error("initializeWasm() must be awaited first!");
42989 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters, entropy_source);
42990 return nativeResponseValue;
42992 // MUST_USE_RES struct LDKCOption_usizeZ TrustedCommitmentTransaction_revokeable_output_index(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
42994 export function TrustedCommitmentTransaction_revokeable_output_index(this_arg: bigint): bigint {
42995 if(!isWasmInitialized) {
42996 throw new Error("initializeWasm() must be awaited first!");
42998 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_revokeable_output_index(this_arg);
42999 return nativeResponseValue;
43001 // 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);
43003 export function TrustedCommitmentTransaction_build_to_local_justice_tx(this_arg: bigint, feerate_per_kw: bigint, destination_script: number): bigint {
43004 if(!isWasmInitialized) {
43005 throw new Error("initializeWasm() must be awaited first!");
43007 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_build_to_local_justice_tx(this_arg, feerate_per_kw, destination_script);
43008 return nativeResponseValue;
43010 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
43012 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
43013 if(!isWasmInitialized) {
43014 throw new Error("initializeWasm() must be awaited first!");
43016 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
43017 return nativeResponseValue;
43019 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
43021 export function InitFeatures_eq(a: bigint, b: bigint): boolean {
43022 if(!isWasmInitialized) {
43023 throw new Error("initializeWasm() must be awaited first!");
43025 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
43026 return nativeResponseValue;
43028 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
43030 export function NodeFeatures_eq(a: bigint, b: bigint): boolean {
43031 if(!isWasmInitialized) {
43032 throw new Error("initializeWasm() must be awaited first!");
43034 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
43035 return nativeResponseValue;
43037 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
43039 export function ChannelFeatures_eq(a: bigint, b: bigint): boolean {
43040 if(!isWasmInitialized) {
43041 throw new Error("initializeWasm() must be awaited first!");
43043 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
43044 return nativeResponseValue;
43046 // bool Bolt11InvoiceFeatures_eq(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR a, const struct LDKBolt11InvoiceFeatures *NONNULL_PTR b);
43048 export function Bolt11InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
43049 if(!isWasmInitialized) {
43050 throw new Error("initializeWasm() must be awaited first!");
43052 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_eq(a, b);
43053 return nativeResponseValue;
43055 // bool OfferFeatures_eq(const struct LDKOfferFeatures *NONNULL_PTR a, const struct LDKOfferFeatures *NONNULL_PTR b);
43057 export function OfferFeatures_eq(a: bigint, b: bigint): boolean {
43058 if(!isWasmInitialized) {
43059 throw new Error("initializeWasm() must be awaited first!");
43061 const nativeResponseValue = wasm.TS_OfferFeatures_eq(a, b);
43062 return nativeResponseValue;
43064 // bool InvoiceRequestFeatures_eq(const struct LDKInvoiceRequestFeatures *NONNULL_PTR a, const struct LDKInvoiceRequestFeatures *NONNULL_PTR b);
43066 export function InvoiceRequestFeatures_eq(a: bigint, b: bigint): boolean {
43067 if(!isWasmInitialized) {
43068 throw new Error("initializeWasm() must be awaited first!");
43070 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_eq(a, b);
43071 return nativeResponseValue;
43073 // bool Bolt12InvoiceFeatures_eq(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR a, const struct LDKBolt12InvoiceFeatures *NONNULL_PTR b);
43075 export function Bolt12InvoiceFeatures_eq(a: bigint, b: bigint): boolean {
43076 if(!isWasmInitialized) {
43077 throw new Error("initializeWasm() must be awaited first!");
43079 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_eq(a, b);
43080 return nativeResponseValue;
43082 // bool BlindedHopFeatures_eq(const struct LDKBlindedHopFeatures *NONNULL_PTR a, const struct LDKBlindedHopFeatures *NONNULL_PTR b);
43084 export function BlindedHopFeatures_eq(a: bigint, b: bigint): boolean {
43085 if(!isWasmInitialized) {
43086 throw new Error("initializeWasm() must be awaited first!");
43088 const nativeResponseValue = wasm.TS_BlindedHopFeatures_eq(a, b);
43089 return nativeResponseValue;
43091 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
43093 export function ChannelTypeFeatures_eq(a: bigint, b: bigint): boolean {
43094 if(!isWasmInitialized) {
43095 throw new Error("initializeWasm() must be awaited first!");
43097 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
43098 return nativeResponseValue;
43100 // uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
43102 export function InitFeatures_clone_ptr(arg: bigint): bigint {
43103 if(!isWasmInitialized) {
43104 throw new Error("initializeWasm() must be awaited first!");
43106 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
43107 return nativeResponseValue;
43109 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
43111 export function InitFeatures_clone(orig: bigint): bigint {
43112 if(!isWasmInitialized) {
43113 throw new Error("initializeWasm() must be awaited first!");
43115 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
43116 return nativeResponseValue;
43118 // uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
43120 export function NodeFeatures_clone_ptr(arg: bigint): bigint {
43121 if(!isWasmInitialized) {
43122 throw new Error("initializeWasm() must be awaited first!");
43124 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
43125 return nativeResponseValue;
43127 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
43129 export function NodeFeatures_clone(orig: bigint): bigint {
43130 if(!isWasmInitialized) {
43131 throw new Error("initializeWasm() must be awaited first!");
43133 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
43134 return nativeResponseValue;
43136 // uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
43138 export function ChannelFeatures_clone_ptr(arg: bigint): bigint {
43139 if(!isWasmInitialized) {
43140 throw new Error("initializeWasm() must be awaited first!");
43142 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
43143 return nativeResponseValue;
43145 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
43147 export function ChannelFeatures_clone(orig: bigint): bigint {
43148 if(!isWasmInitialized) {
43149 throw new Error("initializeWasm() must be awaited first!");
43151 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
43152 return nativeResponseValue;
43154 // uint64_t Bolt11InvoiceFeatures_clone_ptr(LDKBolt11InvoiceFeatures *NONNULL_PTR arg);
43156 export function Bolt11InvoiceFeatures_clone_ptr(arg: bigint): bigint {
43157 if(!isWasmInitialized) {
43158 throw new Error("initializeWasm() must be awaited first!");
43160 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_clone_ptr(arg);
43161 return nativeResponseValue;
43163 // struct LDKBolt11InvoiceFeatures Bolt11InvoiceFeatures_clone(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR orig);
43165 export function Bolt11InvoiceFeatures_clone(orig: bigint): bigint {
43166 if(!isWasmInitialized) {
43167 throw new Error("initializeWasm() must be awaited first!");
43169 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_clone(orig);
43170 return nativeResponseValue;
43172 // uint64_t OfferFeatures_clone_ptr(LDKOfferFeatures *NONNULL_PTR arg);
43174 export function OfferFeatures_clone_ptr(arg: bigint): bigint {
43175 if(!isWasmInitialized) {
43176 throw new Error("initializeWasm() must be awaited first!");
43178 const nativeResponseValue = wasm.TS_OfferFeatures_clone_ptr(arg);
43179 return nativeResponseValue;
43181 // struct LDKOfferFeatures OfferFeatures_clone(const struct LDKOfferFeatures *NONNULL_PTR orig);
43183 export function OfferFeatures_clone(orig: bigint): bigint {
43184 if(!isWasmInitialized) {
43185 throw new Error("initializeWasm() must be awaited first!");
43187 const nativeResponseValue = wasm.TS_OfferFeatures_clone(orig);
43188 return nativeResponseValue;
43190 // uint64_t InvoiceRequestFeatures_clone_ptr(LDKInvoiceRequestFeatures *NONNULL_PTR arg);
43192 export function InvoiceRequestFeatures_clone_ptr(arg: bigint): bigint {
43193 if(!isWasmInitialized) {
43194 throw new Error("initializeWasm() must be awaited first!");
43196 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone_ptr(arg);
43197 return nativeResponseValue;
43199 // struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_clone(const struct LDKInvoiceRequestFeatures *NONNULL_PTR orig);
43201 export function InvoiceRequestFeatures_clone(orig: bigint): bigint {
43202 if(!isWasmInitialized) {
43203 throw new Error("initializeWasm() must be awaited first!");
43205 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_clone(orig);
43206 return nativeResponseValue;
43208 // uint64_t Bolt12InvoiceFeatures_clone_ptr(LDKBolt12InvoiceFeatures *NONNULL_PTR arg);
43210 export function Bolt12InvoiceFeatures_clone_ptr(arg: bigint): bigint {
43211 if(!isWasmInitialized) {
43212 throw new Error("initializeWasm() must be awaited first!");
43214 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone_ptr(arg);
43215 return nativeResponseValue;
43217 // struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_clone(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR orig);
43219 export function Bolt12InvoiceFeatures_clone(orig: bigint): bigint {
43220 if(!isWasmInitialized) {
43221 throw new Error("initializeWasm() must be awaited first!");
43223 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_clone(orig);
43224 return nativeResponseValue;
43226 // uint64_t BlindedHopFeatures_clone_ptr(LDKBlindedHopFeatures *NONNULL_PTR arg);
43228 export function BlindedHopFeatures_clone_ptr(arg: bigint): bigint {
43229 if(!isWasmInitialized) {
43230 throw new Error("initializeWasm() must be awaited first!");
43232 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone_ptr(arg);
43233 return nativeResponseValue;
43235 // struct LDKBlindedHopFeatures BlindedHopFeatures_clone(const struct LDKBlindedHopFeatures *NONNULL_PTR orig);
43237 export function BlindedHopFeatures_clone(orig: bigint): bigint {
43238 if(!isWasmInitialized) {
43239 throw new Error("initializeWasm() must be awaited first!");
43241 const nativeResponseValue = wasm.TS_BlindedHopFeatures_clone(orig);
43242 return nativeResponseValue;
43244 // uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
43246 export function ChannelTypeFeatures_clone_ptr(arg: bigint): bigint {
43247 if(!isWasmInitialized) {
43248 throw new Error("initializeWasm() must be awaited first!");
43250 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
43251 return nativeResponseValue;
43253 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
43255 export function ChannelTypeFeatures_clone(orig: bigint): bigint {
43256 if(!isWasmInitialized) {
43257 throw new Error("initializeWasm() must be awaited first!");
43259 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
43260 return nativeResponseValue;
43262 // uint64_t InitFeatures_hash(const struct LDKInitFeatures *NONNULL_PTR o);
43264 export function InitFeatures_hash(o: bigint): bigint {
43265 if(!isWasmInitialized) {
43266 throw new Error("initializeWasm() must be awaited first!");
43268 const nativeResponseValue = wasm.TS_InitFeatures_hash(o);
43269 return nativeResponseValue;
43271 // uint64_t NodeFeatures_hash(const struct LDKNodeFeatures *NONNULL_PTR o);
43273 export function NodeFeatures_hash(o: bigint): bigint {
43274 if(!isWasmInitialized) {
43275 throw new Error("initializeWasm() must be awaited first!");
43277 const nativeResponseValue = wasm.TS_NodeFeatures_hash(o);
43278 return nativeResponseValue;
43280 // uint64_t ChannelFeatures_hash(const struct LDKChannelFeatures *NONNULL_PTR o);
43282 export function ChannelFeatures_hash(o: bigint): bigint {
43283 if(!isWasmInitialized) {
43284 throw new Error("initializeWasm() must be awaited first!");
43286 const nativeResponseValue = wasm.TS_ChannelFeatures_hash(o);
43287 return nativeResponseValue;
43289 // uint64_t Bolt11InvoiceFeatures_hash(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR o);
43291 export function Bolt11InvoiceFeatures_hash(o: bigint): bigint {
43292 if(!isWasmInitialized) {
43293 throw new Error("initializeWasm() must be awaited first!");
43295 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_hash(o);
43296 return nativeResponseValue;
43298 // uint64_t OfferFeatures_hash(const struct LDKOfferFeatures *NONNULL_PTR o);
43300 export function OfferFeatures_hash(o: bigint): bigint {
43301 if(!isWasmInitialized) {
43302 throw new Error("initializeWasm() must be awaited first!");
43304 const nativeResponseValue = wasm.TS_OfferFeatures_hash(o);
43305 return nativeResponseValue;
43307 // uint64_t InvoiceRequestFeatures_hash(const struct LDKInvoiceRequestFeatures *NONNULL_PTR o);
43309 export function InvoiceRequestFeatures_hash(o: bigint): bigint {
43310 if(!isWasmInitialized) {
43311 throw new Error("initializeWasm() must be awaited first!");
43313 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_hash(o);
43314 return nativeResponseValue;
43316 // uint64_t Bolt12InvoiceFeatures_hash(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR o);
43318 export function Bolt12InvoiceFeatures_hash(o: bigint): bigint {
43319 if(!isWasmInitialized) {
43320 throw new Error("initializeWasm() must be awaited first!");
43322 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_hash(o);
43323 return nativeResponseValue;
43325 // uint64_t BlindedHopFeatures_hash(const struct LDKBlindedHopFeatures *NONNULL_PTR o);
43327 export function BlindedHopFeatures_hash(o: bigint): bigint {
43328 if(!isWasmInitialized) {
43329 throw new Error("initializeWasm() must be awaited first!");
43331 const nativeResponseValue = wasm.TS_BlindedHopFeatures_hash(o);
43332 return nativeResponseValue;
43334 // uint64_t ChannelTypeFeatures_hash(const struct LDKChannelTypeFeatures *NONNULL_PTR o);
43336 export function ChannelTypeFeatures_hash(o: bigint): bigint {
43337 if(!isWasmInitialized) {
43338 throw new Error("initializeWasm() must be awaited first!");
43340 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_hash(o);
43341 return nativeResponseValue;
43343 // void InitFeatures_free(struct LDKInitFeatures this_obj);
43345 export function InitFeatures_free(this_obj: bigint): void {
43346 if(!isWasmInitialized) {
43347 throw new Error("initializeWasm() must be awaited first!");
43349 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
43350 // debug statements here
43352 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
43354 export function NodeFeatures_free(this_obj: bigint): void {
43355 if(!isWasmInitialized) {
43356 throw new Error("initializeWasm() must be awaited first!");
43358 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
43359 // debug statements here
43361 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
43363 export function ChannelFeatures_free(this_obj: bigint): void {
43364 if(!isWasmInitialized) {
43365 throw new Error("initializeWasm() must be awaited first!");
43367 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
43368 // debug statements here
43370 // void Bolt11InvoiceFeatures_free(struct LDKBolt11InvoiceFeatures this_obj);
43372 export function Bolt11InvoiceFeatures_free(this_obj: bigint): void {
43373 if(!isWasmInitialized) {
43374 throw new Error("initializeWasm() must be awaited first!");
43376 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_free(this_obj);
43377 // debug statements here
43379 // void OfferFeatures_free(struct LDKOfferFeatures this_obj);
43381 export function OfferFeatures_free(this_obj: bigint): void {
43382 if(!isWasmInitialized) {
43383 throw new Error("initializeWasm() must be awaited first!");
43385 const nativeResponseValue = wasm.TS_OfferFeatures_free(this_obj);
43386 // debug statements here
43388 // void InvoiceRequestFeatures_free(struct LDKInvoiceRequestFeatures this_obj);
43390 export function InvoiceRequestFeatures_free(this_obj: bigint): void {
43391 if(!isWasmInitialized) {
43392 throw new Error("initializeWasm() must be awaited first!");
43394 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_free(this_obj);
43395 // debug statements here
43397 // void Bolt12InvoiceFeatures_free(struct LDKBolt12InvoiceFeatures this_obj);
43399 export function Bolt12InvoiceFeatures_free(this_obj: bigint): void {
43400 if(!isWasmInitialized) {
43401 throw new Error("initializeWasm() must be awaited first!");
43403 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_free(this_obj);
43404 // debug statements here
43406 // void BlindedHopFeatures_free(struct LDKBlindedHopFeatures this_obj);
43408 export function BlindedHopFeatures_free(this_obj: bigint): void {
43409 if(!isWasmInitialized) {
43410 throw new Error("initializeWasm() must be awaited first!");
43412 const nativeResponseValue = wasm.TS_BlindedHopFeatures_free(this_obj);
43413 // debug statements here
43415 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
43417 export function ChannelTypeFeatures_free(this_obj: bigint): void {
43418 if(!isWasmInitialized) {
43419 throw new Error("initializeWasm() must be awaited first!");
43421 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
43422 // debug statements here
43424 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
43426 export function InitFeatures_empty(): bigint {
43427 if(!isWasmInitialized) {
43428 throw new Error("initializeWasm() must be awaited first!");
43430 const nativeResponseValue = wasm.TS_InitFeatures_empty();
43431 return nativeResponseValue;
43433 // MUST_USE_RES bool InitFeatures_requires_unknown_bits_from(const struct LDKInitFeatures *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR other);
43435 export function InitFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
43436 if(!isWasmInitialized) {
43437 throw new Error("initializeWasm() must be awaited first!");
43439 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits_from(this_arg, other);
43440 return nativeResponseValue;
43442 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
43444 export function InitFeatures_requires_unknown_bits(this_arg: bigint): boolean {
43445 if(!isWasmInitialized) {
43446 throw new Error("initializeWasm() must be awaited first!");
43448 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
43449 return nativeResponseValue;
43451 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_required_feature_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43453 export function InitFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
43454 if(!isWasmInitialized) {
43455 throw new Error("initializeWasm() must be awaited first!");
43457 const nativeResponseValue = wasm.TS_InitFeatures_set_required_feature_bit(this_arg, bit);
43458 return nativeResponseValue;
43460 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_optional_feature_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43462 export function InitFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
43463 if(!isWasmInitialized) {
43464 throw new Error("initializeWasm() must be awaited first!");
43466 const nativeResponseValue = wasm.TS_InitFeatures_set_optional_feature_bit(this_arg, bit);
43467 return nativeResponseValue;
43469 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_required_custom_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43471 export function InitFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
43472 if(!isWasmInitialized) {
43473 throw new Error("initializeWasm() must be awaited first!");
43475 const nativeResponseValue = wasm.TS_InitFeatures_set_required_custom_bit(this_arg, bit);
43476 return nativeResponseValue;
43478 // MUST_USE_RES struct LDKCResult_NoneNoneZ InitFeatures_set_optional_custom_bit(struct LDKInitFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43480 export function InitFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
43481 if(!isWasmInitialized) {
43482 throw new Error("initializeWasm() must be awaited first!");
43484 const nativeResponseValue = wasm.TS_InitFeatures_set_optional_custom_bit(this_arg, bit);
43485 return nativeResponseValue;
43487 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
43489 export function NodeFeatures_empty(): bigint {
43490 if(!isWasmInitialized) {
43491 throw new Error("initializeWasm() must be awaited first!");
43493 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
43494 return nativeResponseValue;
43496 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits_from(const struct LDKNodeFeatures *NONNULL_PTR this_arg, const struct LDKNodeFeatures *NONNULL_PTR other);
43498 export function NodeFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
43499 if(!isWasmInitialized) {
43500 throw new Error("initializeWasm() must be awaited first!");
43502 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits_from(this_arg, other);
43503 return nativeResponseValue;
43505 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
43507 export function NodeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
43508 if(!isWasmInitialized) {
43509 throw new Error("initializeWasm() must be awaited first!");
43511 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
43512 return nativeResponseValue;
43514 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_required_feature_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43516 export function NodeFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
43517 if(!isWasmInitialized) {
43518 throw new Error("initializeWasm() must be awaited first!");
43520 const nativeResponseValue = wasm.TS_NodeFeatures_set_required_feature_bit(this_arg, bit);
43521 return nativeResponseValue;
43523 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_optional_feature_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43525 export function NodeFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
43526 if(!isWasmInitialized) {
43527 throw new Error("initializeWasm() must be awaited first!");
43529 const nativeResponseValue = wasm.TS_NodeFeatures_set_optional_feature_bit(this_arg, bit);
43530 return nativeResponseValue;
43532 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_required_custom_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43534 export function NodeFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
43535 if(!isWasmInitialized) {
43536 throw new Error("initializeWasm() must be awaited first!");
43538 const nativeResponseValue = wasm.TS_NodeFeatures_set_required_custom_bit(this_arg, bit);
43539 return nativeResponseValue;
43541 // MUST_USE_RES struct LDKCResult_NoneNoneZ NodeFeatures_set_optional_custom_bit(struct LDKNodeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43543 export function NodeFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
43544 if(!isWasmInitialized) {
43545 throw new Error("initializeWasm() must be awaited first!");
43547 const nativeResponseValue = wasm.TS_NodeFeatures_set_optional_custom_bit(this_arg, bit);
43548 return nativeResponseValue;
43550 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
43552 export function ChannelFeatures_empty(): bigint {
43553 if(!isWasmInitialized) {
43554 throw new Error("initializeWasm() must be awaited first!");
43556 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
43557 return nativeResponseValue;
43559 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits_from(const struct LDKChannelFeatures *NONNULL_PTR this_arg, const struct LDKChannelFeatures *NONNULL_PTR other);
43561 export function ChannelFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
43562 if(!isWasmInitialized) {
43563 throw new Error("initializeWasm() must be awaited first!");
43565 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits_from(this_arg, other);
43566 return nativeResponseValue;
43568 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
43570 export function ChannelFeatures_requires_unknown_bits(this_arg: bigint): boolean {
43571 if(!isWasmInitialized) {
43572 throw new Error("initializeWasm() must be awaited first!");
43574 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
43575 return nativeResponseValue;
43577 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_required_feature_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43579 export function ChannelFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
43580 if(!isWasmInitialized) {
43581 throw new Error("initializeWasm() must be awaited first!");
43583 const nativeResponseValue = wasm.TS_ChannelFeatures_set_required_feature_bit(this_arg, bit);
43584 return nativeResponseValue;
43586 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_optional_feature_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43588 export function ChannelFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
43589 if(!isWasmInitialized) {
43590 throw new Error("initializeWasm() must be awaited first!");
43592 const nativeResponseValue = wasm.TS_ChannelFeatures_set_optional_feature_bit(this_arg, bit);
43593 return nativeResponseValue;
43595 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_required_custom_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43597 export function ChannelFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
43598 if(!isWasmInitialized) {
43599 throw new Error("initializeWasm() must be awaited first!");
43601 const nativeResponseValue = wasm.TS_ChannelFeatures_set_required_custom_bit(this_arg, bit);
43602 return nativeResponseValue;
43604 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelFeatures_set_optional_custom_bit(struct LDKChannelFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43606 export function ChannelFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
43607 if(!isWasmInitialized) {
43608 throw new Error("initializeWasm() must be awaited first!");
43610 const nativeResponseValue = wasm.TS_ChannelFeatures_set_optional_custom_bit(this_arg, bit);
43611 return nativeResponseValue;
43613 // MUST_USE_RES struct LDKBolt11InvoiceFeatures Bolt11InvoiceFeatures_empty(void);
43615 export function Bolt11InvoiceFeatures_empty(): bigint {
43616 if(!isWasmInitialized) {
43617 throw new Error("initializeWasm() must be awaited first!");
43619 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_empty();
43620 return nativeResponseValue;
43622 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_unknown_bits_from(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, const struct LDKBolt11InvoiceFeatures *NONNULL_PTR other);
43624 export function Bolt11InvoiceFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
43625 if(!isWasmInitialized) {
43626 throw new Error("initializeWasm() must be awaited first!");
43628 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_unknown_bits_from(this_arg, other);
43629 return nativeResponseValue;
43631 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_unknown_bits(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
43633 export function Bolt11InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
43634 if(!isWasmInitialized) {
43635 throw new Error("initializeWasm() must be awaited first!");
43637 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_unknown_bits(this_arg);
43638 return nativeResponseValue;
43640 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_required_feature_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43642 export function Bolt11InvoiceFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
43643 if(!isWasmInitialized) {
43644 throw new Error("initializeWasm() must be awaited first!");
43646 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_required_feature_bit(this_arg, bit);
43647 return nativeResponseValue;
43649 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_optional_feature_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43651 export function Bolt11InvoiceFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
43652 if(!isWasmInitialized) {
43653 throw new Error("initializeWasm() must be awaited first!");
43655 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_optional_feature_bit(this_arg, bit);
43656 return nativeResponseValue;
43658 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_required_custom_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43660 export function Bolt11InvoiceFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
43661 if(!isWasmInitialized) {
43662 throw new Error("initializeWasm() must be awaited first!");
43664 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_required_custom_bit(this_arg, bit);
43665 return nativeResponseValue;
43667 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt11InvoiceFeatures_set_optional_custom_bit(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43669 export function Bolt11InvoiceFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
43670 if(!isWasmInitialized) {
43671 throw new Error("initializeWasm() must be awaited first!");
43673 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_optional_custom_bit(this_arg, bit);
43674 return nativeResponseValue;
43676 // MUST_USE_RES struct LDKOfferFeatures OfferFeatures_empty(void);
43678 export function OfferFeatures_empty(): bigint {
43679 if(!isWasmInitialized) {
43680 throw new Error("initializeWasm() must be awaited first!");
43682 const nativeResponseValue = wasm.TS_OfferFeatures_empty();
43683 return nativeResponseValue;
43685 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits_from(const struct LDKOfferFeatures *NONNULL_PTR this_arg, const struct LDKOfferFeatures *NONNULL_PTR other);
43687 export function OfferFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
43688 if(!isWasmInitialized) {
43689 throw new Error("initializeWasm() must be awaited first!");
43691 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits_from(this_arg, other);
43692 return nativeResponseValue;
43694 // MUST_USE_RES bool OfferFeatures_requires_unknown_bits(const struct LDKOfferFeatures *NONNULL_PTR this_arg);
43696 export function OfferFeatures_requires_unknown_bits(this_arg: bigint): boolean {
43697 if(!isWasmInitialized) {
43698 throw new Error("initializeWasm() must be awaited first!");
43700 const nativeResponseValue = wasm.TS_OfferFeatures_requires_unknown_bits(this_arg);
43701 return nativeResponseValue;
43703 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_required_feature_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43705 export function OfferFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
43706 if(!isWasmInitialized) {
43707 throw new Error("initializeWasm() must be awaited first!");
43709 const nativeResponseValue = wasm.TS_OfferFeatures_set_required_feature_bit(this_arg, bit);
43710 return nativeResponseValue;
43712 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_optional_feature_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43714 export function OfferFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
43715 if(!isWasmInitialized) {
43716 throw new Error("initializeWasm() must be awaited first!");
43718 const nativeResponseValue = wasm.TS_OfferFeatures_set_optional_feature_bit(this_arg, bit);
43719 return nativeResponseValue;
43721 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_required_custom_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43723 export function OfferFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
43724 if(!isWasmInitialized) {
43725 throw new Error("initializeWasm() must be awaited first!");
43727 const nativeResponseValue = wasm.TS_OfferFeatures_set_required_custom_bit(this_arg, bit);
43728 return nativeResponseValue;
43730 // MUST_USE_RES struct LDKCResult_NoneNoneZ OfferFeatures_set_optional_custom_bit(struct LDKOfferFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43732 export function OfferFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
43733 if(!isWasmInitialized) {
43734 throw new Error("initializeWasm() must be awaited first!");
43736 const nativeResponseValue = wasm.TS_OfferFeatures_set_optional_custom_bit(this_arg, bit);
43737 return nativeResponseValue;
43739 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequestFeatures_empty(void);
43741 export function InvoiceRequestFeatures_empty(): bigint {
43742 if(!isWasmInitialized) {
43743 throw new Error("initializeWasm() must be awaited first!");
43745 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_empty();
43746 return nativeResponseValue;
43748 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits_from(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, const struct LDKInvoiceRequestFeatures *NONNULL_PTR other);
43750 export function InvoiceRequestFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
43751 if(!isWasmInitialized) {
43752 throw new Error("initializeWasm() must be awaited first!");
43754 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits_from(this_arg, other);
43755 return nativeResponseValue;
43757 // MUST_USE_RES bool InvoiceRequestFeatures_requires_unknown_bits(const struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg);
43759 export function InvoiceRequestFeatures_requires_unknown_bits(this_arg: bigint): boolean {
43760 if(!isWasmInitialized) {
43761 throw new Error("initializeWasm() must be awaited first!");
43763 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_requires_unknown_bits(this_arg);
43764 return nativeResponseValue;
43766 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_required_feature_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43768 export function InvoiceRequestFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
43769 if(!isWasmInitialized) {
43770 throw new Error("initializeWasm() must be awaited first!");
43772 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_required_feature_bit(this_arg, bit);
43773 return nativeResponseValue;
43775 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_optional_feature_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43777 export function InvoiceRequestFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
43778 if(!isWasmInitialized) {
43779 throw new Error("initializeWasm() must be awaited first!");
43781 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_optional_feature_bit(this_arg, bit);
43782 return nativeResponseValue;
43784 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_required_custom_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43786 export function InvoiceRequestFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
43787 if(!isWasmInitialized) {
43788 throw new Error("initializeWasm() must be awaited first!");
43790 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_required_custom_bit(this_arg, bit);
43791 return nativeResponseValue;
43793 // MUST_USE_RES struct LDKCResult_NoneNoneZ InvoiceRequestFeatures_set_optional_custom_bit(struct LDKInvoiceRequestFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43795 export function InvoiceRequestFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
43796 if(!isWasmInitialized) {
43797 throw new Error("initializeWasm() must be awaited first!");
43799 const nativeResponseValue = wasm.TS_InvoiceRequestFeatures_set_optional_custom_bit(this_arg, bit);
43800 return nativeResponseValue;
43802 // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12InvoiceFeatures_empty(void);
43804 export function Bolt12InvoiceFeatures_empty(): bigint {
43805 if(!isWasmInitialized) {
43806 throw new Error("initializeWasm() must be awaited first!");
43808 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_empty();
43809 return nativeResponseValue;
43811 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_unknown_bits_from(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, const struct LDKBolt12InvoiceFeatures *NONNULL_PTR other);
43813 export function Bolt12InvoiceFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
43814 if(!isWasmInitialized) {
43815 throw new Error("initializeWasm() must be awaited first!");
43817 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_unknown_bits_from(this_arg, other);
43818 return nativeResponseValue;
43820 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_unknown_bits(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
43822 export function Bolt12InvoiceFeatures_requires_unknown_bits(this_arg: bigint): boolean {
43823 if(!isWasmInitialized) {
43824 throw new Error("initializeWasm() must be awaited first!");
43826 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_unknown_bits(this_arg);
43827 return nativeResponseValue;
43829 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_required_feature_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43831 export function Bolt12InvoiceFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
43832 if(!isWasmInitialized) {
43833 throw new Error("initializeWasm() must be awaited first!");
43835 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_required_feature_bit(this_arg, bit);
43836 return nativeResponseValue;
43838 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_optional_feature_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43840 export function Bolt12InvoiceFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
43841 if(!isWasmInitialized) {
43842 throw new Error("initializeWasm() must be awaited first!");
43844 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_optional_feature_bit(this_arg, bit);
43845 return nativeResponseValue;
43847 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_required_custom_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43849 export function Bolt12InvoiceFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
43850 if(!isWasmInitialized) {
43851 throw new Error("initializeWasm() must be awaited first!");
43853 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_required_custom_bit(this_arg, bit);
43854 return nativeResponseValue;
43856 // MUST_USE_RES struct LDKCResult_NoneNoneZ Bolt12InvoiceFeatures_set_optional_custom_bit(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43858 export function Bolt12InvoiceFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
43859 if(!isWasmInitialized) {
43860 throw new Error("initializeWasm() must be awaited first!");
43862 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_optional_custom_bit(this_arg, bit);
43863 return nativeResponseValue;
43865 // MUST_USE_RES struct LDKBlindedHopFeatures BlindedHopFeatures_empty(void);
43867 export function BlindedHopFeatures_empty(): bigint {
43868 if(!isWasmInitialized) {
43869 throw new Error("initializeWasm() must be awaited first!");
43871 const nativeResponseValue = wasm.TS_BlindedHopFeatures_empty();
43872 return nativeResponseValue;
43874 // MUST_USE_RES bool BlindedHopFeatures_requires_unknown_bits_from(const struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, const struct LDKBlindedHopFeatures *NONNULL_PTR other);
43876 export function BlindedHopFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
43877 if(!isWasmInitialized) {
43878 throw new Error("initializeWasm() must be awaited first!");
43880 const nativeResponseValue = wasm.TS_BlindedHopFeatures_requires_unknown_bits_from(this_arg, other);
43881 return nativeResponseValue;
43883 // MUST_USE_RES bool BlindedHopFeatures_requires_unknown_bits(const struct LDKBlindedHopFeatures *NONNULL_PTR this_arg);
43885 export function BlindedHopFeatures_requires_unknown_bits(this_arg: bigint): boolean {
43886 if(!isWasmInitialized) {
43887 throw new Error("initializeWasm() must be awaited first!");
43889 const nativeResponseValue = wasm.TS_BlindedHopFeatures_requires_unknown_bits(this_arg);
43890 return nativeResponseValue;
43892 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_required_feature_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43894 export function BlindedHopFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
43895 if(!isWasmInitialized) {
43896 throw new Error("initializeWasm() must be awaited first!");
43898 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_required_feature_bit(this_arg, bit);
43899 return nativeResponseValue;
43901 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_optional_feature_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43903 export function BlindedHopFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
43904 if(!isWasmInitialized) {
43905 throw new Error("initializeWasm() must be awaited first!");
43907 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_optional_feature_bit(this_arg, bit);
43908 return nativeResponseValue;
43910 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_required_custom_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43912 export function BlindedHopFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
43913 if(!isWasmInitialized) {
43914 throw new Error("initializeWasm() must be awaited first!");
43916 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_required_custom_bit(this_arg, bit);
43917 return nativeResponseValue;
43919 // MUST_USE_RES struct LDKCResult_NoneNoneZ BlindedHopFeatures_set_optional_custom_bit(struct LDKBlindedHopFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43921 export function BlindedHopFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
43922 if(!isWasmInitialized) {
43923 throw new Error("initializeWasm() must be awaited first!");
43925 const nativeResponseValue = wasm.TS_BlindedHopFeatures_set_optional_custom_bit(this_arg, bit);
43926 return nativeResponseValue;
43928 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
43930 export function ChannelTypeFeatures_empty(): bigint {
43931 if(!isWasmInitialized) {
43932 throw new Error("initializeWasm() must be awaited first!");
43934 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
43935 return nativeResponseValue;
43937 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits_from(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, const struct LDKChannelTypeFeatures *NONNULL_PTR other);
43939 export function ChannelTypeFeatures_requires_unknown_bits_from(this_arg: bigint, other: bigint): boolean {
43940 if(!isWasmInitialized) {
43941 throw new Error("initializeWasm() must be awaited first!");
43943 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits_from(this_arg, other);
43944 return nativeResponseValue;
43946 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
43948 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: bigint): boolean {
43949 if(!isWasmInitialized) {
43950 throw new Error("initializeWasm() must be awaited first!");
43952 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
43953 return nativeResponseValue;
43955 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_required_feature_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43957 export function ChannelTypeFeatures_set_required_feature_bit(this_arg: bigint, bit: number): bigint {
43958 if(!isWasmInitialized) {
43959 throw new Error("initializeWasm() must be awaited first!");
43961 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_required_feature_bit(this_arg, bit);
43962 return nativeResponseValue;
43964 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_optional_feature_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43966 export function ChannelTypeFeatures_set_optional_feature_bit(this_arg: bigint, bit: number): bigint {
43967 if(!isWasmInitialized) {
43968 throw new Error("initializeWasm() must be awaited first!");
43970 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_optional_feature_bit(this_arg, bit);
43971 return nativeResponseValue;
43973 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_required_custom_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43975 export function ChannelTypeFeatures_set_required_custom_bit(this_arg: bigint, bit: number): bigint {
43976 if(!isWasmInitialized) {
43977 throw new Error("initializeWasm() must be awaited first!");
43979 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_required_custom_bit(this_arg, bit);
43980 return nativeResponseValue;
43982 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelTypeFeatures_set_optional_custom_bit(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg, uintptr_t bit);
43984 export function ChannelTypeFeatures_set_optional_custom_bit(this_arg: bigint, bit: number): bigint {
43985 if(!isWasmInitialized) {
43986 throw new Error("initializeWasm() must be awaited first!");
43988 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_optional_custom_bit(this_arg, bit);
43989 return nativeResponseValue;
43991 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
43993 export function InitFeatures_write(obj: bigint): number {
43994 if(!isWasmInitialized) {
43995 throw new Error("initializeWasm() must be awaited first!");
43997 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
43998 return nativeResponseValue;
44000 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
44002 export function InitFeatures_read(ser: number): bigint {
44003 if(!isWasmInitialized) {
44004 throw new Error("initializeWasm() must be awaited first!");
44006 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
44007 return nativeResponseValue;
44009 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
44011 export function ChannelFeatures_write(obj: bigint): number {
44012 if(!isWasmInitialized) {
44013 throw new Error("initializeWasm() must be awaited first!");
44015 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
44016 return nativeResponseValue;
44018 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
44020 export function ChannelFeatures_read(ser: number): bigint {
44021 if(!isWasmInitialized) {
44022 throw new Error("initializeWasm() must be awaited first!");
44024 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
44025 return nativeResponseValue;
44027 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
44029 export function NodeFeatures_write(obj: bigint): number {
44030 if(!isWasmInitialized) {
44031 throw new Error("initializeWasm() must be awaited first!");
44033 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
44034 return nativeResponseValue;
44036 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
44038 export function NodeFeatures_read(ser: number): bigint {
44039 if(!isWasmInitialized) {
44040 throw new Error("initializeWasm() must be awaited first!");
44042 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
44043 return nativeResponseValue;
44045 // struct LDKCVec_u8Z Bolt11InvoiceFeatures_write(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR obj);
44047 export function Bolt11InvoiceFeatures_write(obj: bigint): number {
44048 if(!isWasmInitialized) {
44049 throw new Error("initializeWasm() must be awaited first!");
44051 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_write(obj);
44052 return nativeResponseValue;
44054 // struct LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ Bolt11InvoiceFeatures_read(struct LDKu8slice ser);
44056 export function Bolt11InvoiceFeatures_read(ser: number): bigint {
44057 if(!isWasmInitialized) {
44058 throw new Error("initializeWasm() must be awaited first!");
44060 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_read(ser);
44061 return nativeResponseValue;
44063 // struct LDKCVec_u8Z Bolt12InvoiceFeatures_write(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR obj);
44065 export function Bolt12InvoiceFeatures_write(obj: bigint): number {
44066 if(!isWasmInitialized) {
44067 throw new Error("initializeWasm() must be awaited first!");
44069 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_write(obj);
44070 return nativeResponseValue;
44072 // struct LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ Bolt12InvoiceFeatures_read(struct LDKu8slice ser);
44074 export function Bolt12InvoiceFeatures_read(ser: number): bigint {
44075 if(!isWasmInitialized) {
44076 throw new Error("initializeWasm() must be awaited first!");
44078 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_read(ser);
44079 return nativeResponseValue;
44081 // struct LDKCVec_u8Z BlindedHopFeatures_write(const struct LDKBlindedHopFeatures *NONNULL_PTR obj);
44083 export function BlindedHopFeatures_write(obj: bigint): number {
44084 if(!isWasmInitialized) {
44085 throw new Error("initializeWasm() must be awaited first!");
44087 const nativeResponseValue = wasm.TS_BlindedHopFeatures_write(obj);
44088 return nativeResponseValue;
44090 // struct LDKCResult_BlindedHopFeaturesDecodeErrorZ BlindedHopFeatures_read(struct LDKu8slice ser);
44092 export function BlindedHopFeatures_read(ser: number): bigint {
44093 if(!isWasmInitialized) {
44094 throw new Error("initializeWasm() must be awaited first!");
44096 const nativeResponseValue = wasm.TS_BlindedHopFeatures_read(ser);
44097 return nativeResponseValue;
44099 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
44101 export function ChannelTypeFeatures_write(obj: bigint): number {
44102 if(!isWasmInitialized) {
44103 throw new Error("initializeWasm() must be awaited first!");
44105 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
44106 return nativeResponseValue;
44108 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
44110 export function ChannelTypeFeatures_read(ser: number): bigint {
44111 if(!isWasmInitialized) {
44112 throw new Error("initializeWasm() must be awaited first!");
44114 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
44115 return nativeResponseValue;
44117 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
44119 export function InitFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
44120 if(!isWasmInitialized) {
44121 throw new Error("initializeWasm() must be awaited first!");
44123 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
44124 // debug statements here
44126 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
44128 export function InitFeatures_set_data_loss_protect_required(this_arg: bigint): void {
44129 if(!isWasmInitialized) {
44130 throw new Error("initializeWasm() must be awaited first!");
44132 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
44133 // debug statements here
44135 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44137 export function InitFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
44138 if(!isWasmInitialized) {
44139 throw new Error("initializeWasm() must be awaited first!");
44141 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
44142 return nativeResponseValue;
44144 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44146 export function NodeFeatures_set_data_loss_protect_optional(this_arg: bigint): void {
44147 if(!isWasmInitialized) {
44148 throw new Error("initializeWasm() must be awaited first!");
44150 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
44151 // debug statements here
44153 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44155 export function NodeFeatures_set_data_loss_protect_required(this_arg: bigint): void {
44156 if(!isWasmInitialized) {
44157 throw new Error("initializeWasm() must be awaited first!");
44159 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
44160 // debug statements here
44162 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44164 export function NodeFeatures_supports_data_loss_protect(this_arg: bigint): boolean {
44165 if(!isWasmInitialized) {
44166 throw new Error("initializeWasm() must be awaited first!");
44168 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
44169 return nativeResponseValue;
44171 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44173 export function InitFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
44174 if(!isWasmInitialized) {
44175 throw new Error("initializeWasm() must be awaited first!");
44177 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
44178 return nativeResponseValue;
44180 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44182 export function NodeFeatures_requires_data_loss_protect(this_arg: bigint): boolean {
44183 if(!isWasmInitialized) {
44184 throw new Error("initializeWasm() must be awaited first!");
44186 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
44187 return nativeResponseValue;
44189 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
44191 export function InitFeatures_set_initial_routing_sync_optional(this_arg: bigint): void {
44192 if(!isWasmInitialized) {
44193 throw new Error("initializeWasm() must be awaited first!");
44195 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
44196 // debug statements here
44198 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
44200 export function InitFeatures_set_initial_routing_sync_required(this_arg: bigint): void {
44201 if(!isWasmInitialized) {
44202 throw new Error("initializeWasm() must be awaited first!");
44204 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
44205 // debug statements here
44207 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44209 export function InitFeatures_initial_routing_sync(this_arg: bigint): boolean {
44210 if(!isWasmInitialized) {
44211 throw new Error("initializeWasm() must be awaited first!");
44213 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
44214 return nativeResponseValue;
44216 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
44218 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
44219 if(!isWasmInitialized) {
44220 throw new Error("initializeWasm() must be awaited first!");
44222 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
44223 // debug statements here
44225 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
44227 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
44228 if(!isWasmInitialized) {
44229 throw new Error("initializeWasm() must be awaited first!");
44231 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
44232 // debug statements here
44234 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44236 export function InitFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
44237 if(!isWasmInitialized) {
44238 throw new Error("initializeWasm() must be awaited first!");
44240 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
44241 return nativeResponseValue;
44243 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44245 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: bigint): void {
44246 if(!isWasmInitialized) {
44247 throw new Error("initializeWasm() must be awaited first!");
44249 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
44250 // debug statements here
44252 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44254 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: bigint): void {
44255 if(!isWasmInitialized) {
44256 throw new Error("initializeWasm() must be awaited first!");
44258 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
44259 // debug statements here
44261 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44263 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: bigint): boolean {
44264 if(!isWasmInitialized) {
44265 throw new Error("initializeWasm() must be awaited first!");
44267 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
44268 return nativeResponseValue;
44270 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44272 export function InitFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
44273 if(!isWasmInitialized) {
44274 throw new Error("initializeWasm() must be awaited first!");
44276 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
44277 return nativeResponseValue;
44279 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44281 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: bigint): boolean {
44282 if(!isWasmInitialized) {
44283 throw new Error("initializeWasm() must be awaited first!");
44285 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
44286 return nativeResponseValue;
44288 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
44290 export function InitFeatures_set_gossip_queries_optional(this_arg: bigint): void {
44291 if(!isWasmInitialized) {
44292 throw new Error("initializeWasm() must be awaited first!");
44294 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
44295 // debug statements here
44297 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
44299 export function InitFeatures_set_gossip_queries_required(this_arg: bigint): void {
44300 if(!isWasmInitialized) {
44301 throw new Error("initializeWasm() must be awaited first!");
44303 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
44304 // debug statements here
44306 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44308 export function InitFeatures_supports_gossip_queries(this_arg: bigint): boolean {
44309 if(!isWasmInitialized) {
44310 throw new Error("initializeWasm() must be awaited first!");
44312 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
44313 return nativeResponseValue;
44315 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44317 export function NodeFeatures_set_gossip_queries_optional(this_arg: bigint): void {
44318 if(!isWasmInitialized) {
44319 throw new Error("initializeWasm() must be awaited first!");
44321 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
44322 // debug statements here
44324 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44326 export function NodeFeatures_set_gossip_queries_required(this_arg: bigint): void {
44327 if(!isWasmInitialized) {
44328 throw new Error("initializeWasm() must be awaited first!");
44330 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
44331 // debug statements here
44333 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44335 export function NodeFeatures_supports_gossip_queries(this_arg: bigint): boolean {
44336 if(!isWasmInitialized) {
44337 throw new Error("initializeWasm() must be awaited first!");
44339 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
44340 return nativeResponseValue;
44342 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44344 export function InitFeatures_requires_gossip_queries(this_arg: bigint): boolean {
44345 if(!isWasmInitialized) {
44346 throw new Error("initializeWasm() must be awaited first!");
44348 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
44349 return nativeResponseValue;
44351 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44353 export function NodeFeatures_requires_gossip_queries(this_arg: bigint): boolean {
44354 if(!isWasmInitialized) {
44355 throw new Error("initializeWasm() must be awaited first!");
44357 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
44358 return nativeResponseValue;
44360 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
44362 export function InitFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
44363 if(!isWasmInitialized) {
44364 throw new Error("initializeWasm() must be awaited first!");
44366 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
44367 // debug statements here
44369 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
44371 export function InitFeatures_set_variable_length_onion_required(this_arg: bigint): void {
44372 if(!isWasmInitialized) {
44373 throw new Error("initializeWasm() must be awaited first!");
44375 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
44376 // debug statements here
44378 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44380 export function InitFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
44381 if(!isWasmInitialized) {
44382 throw new Error("initializeWasm() must be awaited first!");
44384 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
44385 return nativeResponseValue;
44387 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44389 export function NodeFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
44390 if(!isWasmInitialized) {
44391 throw new Error("initializeWasm() must be awaited first!");
44393 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
44394 // debug statements here
44396 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44398 export function NodeFeatures_set_variable_length_onion_required(this_arg: bigint): void {
44399 if(!isWasmInitialized) {
44400 throw new Error("initializeWasm() must be awaited first!");
44402 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
44403 // debug statements here
44405 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44407 export function NodeFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
44408 if(!isWasmInitialized) {
44409 throw new Error("initializeWasm() must be awaited first!");
44411 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
44412 return nativeResponseValue;
44414 // void Bolt11InvoiceFeatures_set_variable_length_onion_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44416 export function Bolt11InvoiceFeatures_set_variable_length_onion_optional(this_arg: bigint): void {
44417 if(!isWasmInitialized) {
44418 throw new Error("initializeWasm() must be awaited first!");
44420 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_variable_length_onion_optional(this_arg);
44421 // debug statements here
44423 // void Bolt11InvoiceFeatures_set_variable_length_onion_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44425 export function Bolt11InvoiceFeatures_set_variable_length_onion_required(this_arg: bigint): void {
44426 if(!isWasmInitialized) {
44427 throw new Error("initializeWasm() must be awaited first!");
44429 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_variable_length_onion_required(this_arg);
44430 // debug statements here
44432 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_variable_length_onion(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44434 export function Bolt11InvoiceFeatures_supports_variable_length_onion(this_arg: bigint): boolean {
44435 if(!isWasmInitialized) {
44436 throw new Error("initializeWasm() must be awaited first!");
44438 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_variable_length_onion(this_arg);
44439 return nativeResponseValue;
44441 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44443 export function InitFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
44444 if(!isWasmInitialized) {
44445 throw new Error("initializeWasm() must be awaited first!");
44447 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
44448 return nativeResponseValue;
44450 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44452 export function NodeFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
44453 if(!isWasmInitialized) {
44454 throw new Error("initializeWasm() must be awaited first!");
44456 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
44457 return nativeResponseValue;
44459 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_variable_length_onion(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44461 export function Bolt11InvoiceFeatures_requires_variable_length_onion(this_arg: bigint): boolean {
44462 if(!isWasmInitialized) {
44463 throw new Error("initializeWasm() must be awaited first!");
44465 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_variable_length_onion(this_arg);
44466 return nativeResponseValue;
44468 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
44470 export function InitFeatures_set_static_remote_key_optional(this_arg: bigint): void {
44471 if(!isWasmInitialized) {
44472 throw new Error("initializeWasm() must be awaited first!");
44474 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
44475 // debug statements here
44477 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
44479 export function InitFeatures_set_static_remote_key_required(this_arg: bigint): void {
44480 if(!isWasmInitialized) {
44481 throw new Error("initializeWasm() must be awaited first!");
44483 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
44484 // debug statements here
44486 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44488 export function InitFeatures_supports_static_remote_key(this_arg: bigint): boolean {
44489 if(!isWasmInitialized) {
44490 throw new Error("initializeWasm() must be awaited first!");
44492 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
44493 return nativeResponseValue;
44495 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44497 export function NodeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
44498 if(!isWasmInitialized) {
44499 throw new Error("initializeWasm() must be awaited first!");
44501 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
44502 // debug statements here
44504 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44506 export function NodeFeatures_set_static_remote_key_required(this_arg: bigint): void {
44507 if(!isWasmInitialized) {
44508 throw new Error("initializeWasm() must be awaited first!");
44510 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
44511 // debug statements here
44513 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44515 export function NodeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
44516 if(!isWasmInitialized) {
44517 throw new Error("initializeWasm() must be awaited first!");
44519 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
44520 return nativeResponseValue;
44522 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
44524 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: bigint): void {
44525 if(!isWasmInitialized) {
44526 throw new Error("initializeWasm() must be awaited first!");
44528 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
44529 // debug statements here
44531 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
44533 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: bigint): void {
44534 if(!isWasmInitialized) {
44535 throw new Error("initializeWasm() must be awaited first!");
44537 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
44538 // debug statements here
44540 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
44542 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: bigint): boolean {
44543 if(!isWasmInitialized) {
44544 throw new Error("initializeWasm() must be awaited first!");
44546 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
44547 return nativeResponseValue;
44549 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44551 export function InitFeatures_requires_static_remote_key(this_arg: bigint): boolean {
44552 if(!isWasmInitialized) {
44553 throw new Error("initializeWasm() must be awaited first!");
44555 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
44556 return nativeResponseValue;
44558 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44560 export function NodeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
44561 if(!isWasmInitialized) {
44562 throw new Error("initializeWasm() must be awaited first!");
44564 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
44565 return nativeResponseValue;
44567 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
44569 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: bigint): boolean {
44570 if(!isWasmInitialized) {
44571 throw new Error("initializeWasm() must be awaited first!");
44573 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
44574 return nativeResponseValue;
44576 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
44578 export function InitFeatures_set_payment_secret_optional(this_arg: bigint): void {
44579 if(!isWasmInitialized) {
44580 throw new Error("initializeWasm() must be awaited first!");
44582 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
44583 // debug statements here
44585 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
44587 export function InitFeatures_set_payment_secret_required(this_arg: bigint): void {
44588 if(!isWasmInitialized) {
44589 throw new Error("initializeWasm() must be awaited first!");
44591 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
44592 // debug statements here
44594 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44596 export function InitFeatures_supports_payment_secret(this_arg: bigint): boolean {
44597 if(!isWasmInitialized) {
44598 throw new Error("initializeWasm() must be awaited first!");
44600 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
44601 return nativeResponseValue;
44603 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44605 export function NodeFeatures_set_payment_secret_optional(this_arg: bigint): void {
44606 if(!isWasmInitialized) {
44607 throw new Error("initializeWasm() must be awaited first!");
44609 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
44610 // debug statements here
44612 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44614 export function NodeFeatures_set_payment_secret_required(this_arg: bigint): void {
44615 if(!isWasmInitialized) {
44616 throw new Error("initializeWasm() must be awaited first!");
44618 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
44619 // debug statements here
44621 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44623 export function NodeFeatures_supports_payment_secret(this_arg: bigint): boolean {
44624 if(!isWasmInitialized) {
44625 throw new Error("initializeWasm() must be awaited first!");
44627 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
44628 return nativeResponseValue;
44630 // void Bolt11InvoiceFeatures_set_payment_secret_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44632 export function Bolt11InvoiceFeatures_set_payment_secret_optional(this_arg: bigint): void {
44633 if(!isWasmInitialized) {
44634 throw new Error("initializeWasm() must be awaited first!");
44636 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_secret_optional(this_arg);
44637 // debug statements here
44639 // void Bolt11InvoiceFeatures_set_payment_secret_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44641 export function Bolt11InvoiceFeatures_set_payment_secret_required(this_arg: bigint): void {
44642 if(!isWasmInitialized) {
44643 throw new Error("initializeWasm() must be awaited first!");
44645 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_secret_required(this_arg);
44646 // debug statements here
44648 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_payment_secret(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44650 export function Bolt11InvoiceFeatures_supports_payment_secret(this_arg: bigint): boolean {
44651 if(!isWasmInitialized) {
44652 throw new Error("initializeWasm() must be awaited first!");
44654 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_payment_secret(this_arg);
44655 return nativeResponseValue;
44657 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44659 export function InitFeatures_requires_payment_secret(this_arg: bigint): boolean {
44660 if(!isWasmInitialized) {
44661 throw new Error("initializeWasm() must be awaited first!");
44663 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
44664 return nativeResponseValue;
44666 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44668 export function NodeFeatures_requires_payment_secret(this_arg: bigint): boolean {
44669 if(!isWasmInitialized) {
44670 throw new Error("initializeWasm() must be awaited first!");
44672 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
44673 return nativeResponseValue;
44675 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_payment_secret(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44677 export function Bolt11InvoiceFeatures_requires_payment_secret(this_arg: bigint): boolean {
44678 if(!isWasmInitialized) {
44679 throw new Error("initializeWasm() must be awaited first!");
44681 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_payment_secret(this_arg);
44682 return nativeResponseValue;
44684 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
44686 export function InitFeatures_set_basic_mpp_optional(this_arg: bigint): void {
44687 if(!isWasmInitialized) {
44688 throw new Error("initializeWasm() must be awaited first!");
44690 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
44691 // debug statements here
44693 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
44695 export function InitFeatures_set_basic_mpp_required(this_arg: bigint): void {
44696 if(!isWasmInitialized) {
44697 throw new Error("initializeWasm() must be awaited first!");
44699 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
44700 // debug statements here
44702 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44704 export function InitFeatures_supports_basic_mpp(this_arg: bigint): boolean {
44705 if(!isWasmInitialized) {
44706 throw new Error("initializeWasm() must be awaited first!");
44708 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
44709 return nativeResponseValue;
44711 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44713 export function NodeFeatures_set_basic_mpp_optional(this_arg: bigint): void {
44714 if(!isWasmInitialized) {
44715 throw new Error("initializeWasm() must be awaited first!");
44717 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
44718 // debug statements here
44720 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44722 export function NodeFeatures_set_basic_mpp_required(this_arg: bigint): void {
44723 if(!isWasmInitialized) {
44724 throw new Error("initializeWasm() must be awaited first!");
44726 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
44727 // debug statements here
44729 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44731 export function NodeFeatures_supports_basic_mpp(this_arg: bigint): boolean {
44732 if(!isWasmInitialized) {
44733 throw new Error("initializeWasm() must be awaited first!");
44735 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
44736 return nativeResponseValue;
44738 // void Bolt11InvoiceFeatures_set_basic_mpp_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44740 export function Bolt11InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
44741 if(!isWasmInitialized) {
44742 throw new Error("initializeWasm() must be awaited first!");
44744 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_basic_mpp_optional(this_arg);
44745 // debug statements here
44747 // void Bolt11InvoiceFeatures_set_basic_mpp_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44749 export function Bolt11InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
44750 if(!isWasmInitialized) {
44751 throw new Error("initializeWasm() must be awaited first!");
44753 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_basic_mpp_required(this_arg);
44754 // debug statements here
44756 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_basic_mpp(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44758 export function Bolt11InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
44759 if(!isWasmInitialized) {
44760 throw new Error("initializeWasm() must be awaited first!");
44762 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_basic_mpp(this_arg);
44763 return nativeResponseValue;
44765 // void Bolt12InvoiceFeatures_set_basic_mpp_optional(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
44767 export function Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg: bigint): void {
44768 if(!isWasmInitialized) {
44769 throw new Error("initializeWasm() must be awaited first!");
44771 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_optional(this_arg);
44772 // debug statements here
44774 // void Bolt12InvoiceFeatures_set_basic_mpp_required(struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
44776 export function Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg: bigint): void {
44777 if(!isWasmInitialized) {
44778 throw new Error("initializeWasm() must be awaited first!");
44780 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_set_basic_mpp_required(this_arg);
44781 // debug statements here
44783 // MUST_USE_RES bool Bolt12InvoiceFeatures_supports_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
44785 export function Bolt12InvoiceFeatures_supports_basic_mpp(this_arg: bigint): boolean {
44786 if(!isWasmInitialized) {
44787 throw new Error("initializeWasm() must be awaited first!");
44789 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_supports_basic_mpp(this_arg);
44790 return nativeResponseValue;
44792 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44794 export function InitFeatures_requires_basic_mpp(this_arg: bigint): boolean {
44795 if(!isWasmInitialized) {
44796 throw new Error("initializeWasm() must be awaited first!");
44798 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
44799 return nativeResponseValue;
44801 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44803 export function NodeFeatures_requires_basic_mpp(this_arg: bigint): boolean {
44804 if(!isWasmInitialized) {
44805 throw new Error("initializeWasm() must be awaited first!");
44807 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
44808 return nativeResponseValue;
44810 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_basic_mpp(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
44812 export function Bolt11InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
44813 if(!isWasmInitialized) {
44814 throw new Error("initializeWasm() must be awaited first!");
44816 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_basic_mpp(this_arg);
44817 return nativeResponseValue;
44819 // MUST_USE_RES bool Bolt12InvoiceFeatures_requires_basic_mpp(const struct LDKBolt12InvoiceFeatures *NONNULL_PTR this_arg);
44821 export function Bolt12InvoiceFeatures_requires_basic_mpp(this_arg: bigint): boolean {
44822 if(!isWasmInitialized) {
44823 throw new Error("initializeWasm() must be awaited first!");
44825 const nativeResponseValue = wasm.TS_Bolt12InvoiceFeatures_requires_basic_mpp(this_arg);
44826 return nativeResponseValue;
44828 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
44830 export function InitFeatures_set_wumbo_optional(this_arg: bigint): void {
44831 if(!isWasmInitialized) {
44832 throw new Error("initializeWasm() must be awaited first!");
44834 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
44835 // debug statements here
44837 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
44839 export function InitFeatures_set_wumbo_required(this_arg: bigint): void {
44840 if(!isWasmInitialized) {
44841 throw new Error("initializeWasm() must be awaited first!");
44843 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
44844 // debug statements here
44846 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44848 export function InitFeatures_supports_wumbo(this_arg: bigint): boolean {
44849 if(!isWasmInitialized) {
44850 throw new Error("initializeWasm() must be awaited first!");
44852 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
44853 return nativeResponseValue;
44855 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44857 export function NodeFeatures_set_wumbo_optional(this_arg: bigint): void {
44858 if(!isWasmInitialized) {
44859 throw new Error("initializeWasm() must be awaited first!");
44861 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
44862 // debug statements here
44864 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44866 export function NodeFeatures_set_wumbo_required(this_arg: bigint): void {
44867 if(!isWasmInitialized) {
44868 throw new Error("initializeWasm() must be awaited first!");
44870 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
44871 // debug statements here
44873 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44875 export function NodeFeatures_supports_wumbo(this_arg: bigint): boolean {
44876 if(!isWasmInitialized) {
44877 throw new Error("initializeWasm() must be awaited first!");
44879 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
44880 return nativeResponseValue;
44882 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44884 export function InitFeatures_requires_wumbo(this_arg: bigint): boolean {
44885 if(!isWasmInitialized) {
44886 throw new Error("initializeWasm() must be awaited first!");
44888 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
44889 return nativeResponseValue;
44891 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44893 export function NodeFeatures_requires_wumbo(this_arg: bigint): boolean {
44894 if(!isWasmInitialized) {
44895 throw new Error("initializeWasm() must be awaited first!");
44897 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
44898 return nativeResponseValue;
44900 // void InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
44902 export function InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
44903 if(!isWasmInitialized) {
44904 throw new Error("initializeWasm() must be awaited first!");
44906 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
44907 // debug statements here
44909 // void InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
44911 export function InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
44912 if(!isWasmInitialized) {
44913 throw new Error("initializeWasm() must be awaited first!");
44915 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
44916 // debug statements here
44918 // MUST_USE_RES bool InitFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44920 export function InitFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
44921 if(!isWasmInitialized) {
44922 throw new Error("initializeWasm() must be awaited first!");
44924 const nativeResponseValue = wasm.TS_InitFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
44925 return nativeResponseValue;
44927 // void NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44929 export function NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
44930 if(!isWasmInitialized) {
44931 throw new Error("initializeWasm() must be awaited first!");
44933 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
44934 // debug statements here
44936 // void NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
44938 export function NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
44939 if(!isWasmInitialized) {
44940 throw new Error("initializeWasm() must be awaited first!");
44942 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
44943 // debug statements here
44945 // MUST_USE_RES bool NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44947 export function NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
44948 if(!isWasmInitialized) {
44949 throw new Error("initializeWasm() must be awaited first!");
44951 const nativeResponseValue = wasm.TS_NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
44952 return nativeResponseValue;
44954 // void ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
44956 export function ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg: bigint): void {
44957 if(!isWasmInitialized) {
44958 throw new Error("initializeWasm() must be awaited first!");
44960 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this_arg);
44961 // debug statements here
44963 // void ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
44965 export function ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg: bigint): void {
44966 if(!isWasmInitialized) {
44967 throw new Error("initializeWasm() must be awaited first!");
44969 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this_arg);
44970 // debug statements here
44972 // MUST_USE_RES bool ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
44974 export function ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
44975 if(!isWasmInitialized) {
44976 throw new Error("initializeWasm() must be awaited first!");
44978 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(this_arg);
44979 return nativeResponseValue;
44981 // MUST_USE_RES bool InitFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
44983 export function InitFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
44984 if(!isWasmInitialized) {
44985 throw new Error("initializeWasm() must be awaited first!");
44987 const nativeResponseValue = wasm.TS_InitFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
44988 return nativeResponseValue;
44990 // MUST_USE_RES bool NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
44992 export function NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
44993 if(!isWasmInitialized) {
44994 throw new Error("initializeWasm() must be awaited first!");
44996 const nativeResponseValue = wasm.TS_NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
44997 return nativeResponseValue;
44999 // MUST_USE_RES bool ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45001 export function ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg: bigint): boolean {
45002 if(!isWasmInitialized) {
45003 throw new Error("initializeWasm() must be awaited first!");
45005 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(this_arg);
45006 return nativeResponseValue;
45008 // void InitFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
45010 export function InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
45011 if(!isWasmInitialized) {
45012 throw new Error("initializeWasm() must be awaited first!");
45014 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
45015 // debug statements here
45017 // void InitFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
45019 export function InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
45020 if(!isWasmInitialized) {
45021 throw new Error("initializeWasm() must be awaited first!");
45023 const nativeResponseValue = wasm.TS_InitFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
45024 // debug statements here
45026 // MUST_USE_RES bool InitFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45028 export function InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
45029 if(!isWasmInitialized) {
45030 throw new Error("initializeWasm() must be awaited first!");
45032 const nativeResponseValue = wasm.TS_InitFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
45033 return nativeResponseValue;
45035 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45037 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
45038 if(!isWasmInitialized) {
45039 throw new Error("initializeWasm() must be awaited first!");
45041 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
45042 // debug statements here
45044 // void NodeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45046 export function NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
45047 if(!isWasmInitialized) {
45048 throw new Error("initializeWasm() must be awaited first!");
45050 const nativeResponseValue = wasm.TS_NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
45051 // debug statements here
45053 // MUST_USE_RES bool NodeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45055 export function NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
45056 if(!isWasmInitialized) {
45057 throw new Error("initializeWasm() must be awaited first!");
45059 const nativeResponseValue = wasm.TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
45060 return nativeResponseValue;
45062 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45064 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg: bigint): void {
45065 if(!isWasmInitialized) {
45066 throw new Error("initializeWasm() must be awaited first!");
45068 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(this_arg);
45069 // debug statements here
45071 // void ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45073 export function ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg: bigint): void {
45074 if(!isWasmInitialized) {
45075 throw new Error("initializeWasm() must be awaited first!");
45077 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(this_arg);
45078 // debug statements here
45080 // MUST_USE_RES bool ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45082 export function ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
45083 if(!isWasmInitialized) {
45084 throw new Error("initializeWasm() must be awaited first!");
45086 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(this_arg);
45087 return nativeResponseValue;
45089 // MUST_USE_RES bool InitFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45091 export function InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
45092 if(!isWasmInitialized) {
45093 throw new Error("initializeWasm() must be awaited first!");
45095 const nativeResponseValue = wasm.TS_InitFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
45096 return nativeResponseValue;
45098 // MUST_USE_RES bool NodeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45100 export function NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
45101 if(!isWasmInitialized) {
45102 throw new Error("initializeWasm() must be awaited first!");
45104 const nativeResponseValue = wasm.TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
45105 return nativeResponseValue;
45107 // MUST_USE_RES bool ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45109 export function ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg: bigint): boolean {
45110 if(!isWasmInitialized) {
45111 throw new Error("initializeWasm() must be awaited first!");
45113 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(this_arg);
45114 return nativeResponseValue;
45116 // void InitFeatures_set_route_blinding_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
45118 export function InitFeatures_set_route_blinding_optional(this_arg: bigint): void {
45119 if(!isWasmInitialized) {
45120 throw new Error("initializeWasm() must be awaited first!");
45122 const nativeResponseValue = wasm.TS_InitFeatures_set_route_blinding_optional(this_arg);
45123 // debug statements here
45125 // void InitFeatures_set_route_blinding_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
45127 export function InitFeatures_set_route_blinding_required(this_arg: bigint): void {
45128 if(!isWasmInitialized) {
45129 throw new Error("initializeWasm() must be awaited first!");
45131 const nativeResponseValue = wasm.TS_InitFeatures_set_route_blinding_required(this_arg);
45132 // debug statements here
45134 // MUST_USE_RES bool InitFeatures_supports_route_blinding(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45136 export function InitFeatures_supports_route_blinding(this_arg: bigint): boolean {
45137 if(!isWasmInitialized) {
45138 throw new Error("initializeWasm() must be awaited first!");
45140 const nativeResponseValue = wasm.TS_InitFeatures_supports_route_blinding(this_arg);
45141 return nativeResponseValue;
45143 // void NodeFeatures_set_route_blinding_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45145 export function NodeFeatures_set_route_blinding_optional(this_arg: bigint): void {
45146 if(!isWasmInitialized) {
45147 throw new Error("initializeWasm() must be awaited first!");
45149 const nativeResponseValue = wasm.TS_NodeFeatures_set_route_blinding_optional(this_arg);
45150 // debug statements here
45152 // void NodeFeatures_set_route_blinding_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45154 export function NodeFeatures_set_route_blinding_required(this_arg: bigint): void {
45155 if(!isWasmInitialized) {
45156 throw new Error("initializeWasm() must be awaited first!");
45158 const nativeResponseValue = wasm.TS_NodeFeatures_set_route_blinding_required(this_arg);
45159 // debug statements here
45161 // MUST_USE_RES bool NodeFeatures_supports_route_blinding(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45163 export function NodeFeatures_supports_route_blinding(this_arg: bigint): boolean {
45164 if(!isWasmInitialized) {
45165 throw new Error("initializeWasm() must be awaited first!");
45167 const nativeResponseValue = wasm.TS_NodeFeatures_supports_route_blinding(this_arg);
45168 return nativeResponseValue;
45170 // MUST_USE_RES bool InitFeatures_requires_route_blinding(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45172 export function InitFeatures_requires_route_blinding(this_arg: bigint): boolean {
45173 if(!isWasmInitialized) {
45174 throw new Error("initializeWasm() must be awaited first!");
45176 const nativeResponseValue = wasm.TS_InitFeatures_requires_route_blinding(this_arg);
45177 return nativeResponseValue;
45179 // MUST_USE_RES bool NodeFeatures_requires_route_blinding(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45181 export function NodeFeatures_requires_route_blinding(this_arg: bigint): boolean {
45182 if(!isWasmInitialized) {
45183 throw new Error("initializeWasm() must be awaited first!");
45185 const nativeResponseValue = wasm.TS_NodeFeatures_requires_route_blinding(this_arg);
45186 return nativeResponseValue;
45188 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
45190 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
45191 if(!isWasmInitialized) {
45192 throw new Error("initializeWasm() must be awaited first!");
45194 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
45195 // debug statements here
45197 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
45199 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
45200 if(!isWasmInitialized) {
45201 throw new Error("initializeWasm() must be awaited first!");
45203 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
45204 // debug statements here
45206 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45208 export function InitFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
45209 if(!isWasmInitialized) {
45210 throw new Error("initializeWasm() must be awaited first!");
45212 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
45213 return nativeResponseValue;
45215 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45217 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: bigint): void {
45218 if(!isWasmInitialized) {
45219 throw new Error("initializeWasm() must be awaited first!");
45221 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
45222 // debug statements here
45224 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45226 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: bigint): void {
45227 if(!isWasmInitialized) {
45228 throw new Error("initializeWasm() must be awaited first!");
45230 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
45231 // debug statements here
45233 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45235 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: bigint): boolean {
45236 if(!isWasmInitialized) {
45237 throw new Error("initializeWasm() must be awaited first!");
45239 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
45240 return nativeResponseValue;
45242 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45244 export function InitFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
45245 if(!isWasmInitialized) {
45246 throw new Error("initializeWasm() must be awaited first!");
45248 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
45249 return nativeResponseValue;
45251 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45253 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: bigint): boolean {
45254 if(!isWasmInitialized) {
45255 throw new Error("initializeWasm() must be awaited first!");
45257 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
45258 return nativeResponseValue;
45260 // void InitFeatures_set_taproot_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
45262 export function InitFeatures_set_taproot_optional(this_arg: bigint): void {
45263 if(!isWasmInitialized) {
45264 throw new Error("initializeWasm() must be awaited first!");
45266 const nativeResponseValue = wasm.TS_InitFeatures_set_taproot_optional(this_arg);
45267 // debug statements here
45269 // void InitFeatures_set_taproot_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
45271 export function InitFeatures_set_taproot_required(this_arg: bigint): void {
45272 if(!isWasmInitialized) {
45273 throw new Error("initializeWasm() must be awaited first!");
45275 const nativeResponseValue = wasm.TS_InitFeatures_set_taproot_required(this_arg);
45276 // debug statements here
45278 // MUST_USE_RES bool InitFeatures_supports_taproot(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45280 export function InitFeatures_supports_taproot(this_arg: bigint): boolean {
45281 if(!isWasmInitialized) {
45282 throw new Error("initializeWasm() must be awaited first!");
45284 const nativeResponseValue = wasm.TS_InitFeatures_supports_taproot(this_arg);
45285 return nativeResponseValue;
45287 // void NodeFeatures_set_taproot_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45289 export function NodeFeatures_set_taproot_optional(this_arg: bigint): void {
45290 if(!isWasmInitialized) {
45291 throw new Error("initializeWasm() must be awaited first!");
45293 const nativeResponseValue = wasm.TS_NodeFeatures_set_taproot_optional(this_arg);
45294 // debug statements here
45296 // void NodeFeatures_set_taproot_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45298 export function NodeFeatures_set_taproot_required(this_arg: bigint): void {
45299 if(!isWasmInitialized) {
45300 throw new Error("initializeWasm() must be awaited first!");
45302 const nativeResponseValue = wasm.TS_NodeFeatures_set_taproot_required(this_arg);
45303 // debug statements here
45305 // MUST_USE_RES bool NodeFeatures_supports_taproot(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45307 export function NodeFeatures_supports_taproot(this_arg: bigint): boolean {
45308 if(!isWasmInitialized) {
45309 throw new Error("initializeWasm() must be awaited first!");
45311 const nativeResponseValue = wasm.TS_NodeFeatures_supports_taproot(this_arg);
45312 return nativeResponseValue;
45314 // void ChannelTypeFeatures_set_taproot_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45316 export function ChannelTypeFeatures_set_taproot_optional(this_arg: bigint): void {
45317 if(!isWasmInitialized) {
45318 throw new Error("initializeWasm() must be awaited first!");
45320 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_taproot_optional(this_arg);
45321 // debug statements here
45323 // void ChannelTypeFeatures_set_taproot_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45325 export function ChannelTypeFeatures_set_taproot_required(this_arg: bigint): void {
45326 if(!isWasmInitialized) {
45327 throw new Error("initializeWasm() must be awaited first!");
45329 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_taproot_required(this_arg);
45330 // debug statements here
45332 // MUST_USE_RES bool ChannelTypeFeatures_supports_taproot(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45334 export function ChannelTypeFeatures_supports_taproot(this_arg: bigint): boolean {
45335 if(!isWasmInitialized) {
45336 throw new Error("initializeWasm() must be awaited first!");
45338 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_taproot(this_arg);
45339 return nativeResponseValue;
45341 // MUST_USE_RES bool InitFeatures_requires_taproot(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45343 export function InitFeatures_requires_taproot(this_arg: bigint): boolean {
45344 if(!isWasmInitialized) {
45345 throw new Error("initializeWasm() must be awaited first!");
45347 const nativeResponseValue = wasm.TS_InitFeatures_requires_taproot(this_arg);
45348 return nativeResponseValue;
45350 // MUST_USE_RES bool NodeFeatures_requires_taproot(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45352 export function NodeFeatures_requires_taproot(this_arg: bigint): boolean {
45353 if(!isWasmInitialized) {
45354 throw new Error("initializeWasm() must be awaited first!");
45356 const nativeResponseValue = wasm.TS_NodeFeatures_requires_taproot(this_arg);
45357 return nativeResponseValue;
45359 // MUST_USE_RES bool ChannelTypeFeatures_requires_taproot(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45361 export function ChannelTypeFeatures_requires_taproot(this_arg: bigint): boolean {
45362 if(!isWasmInitialized) {
45363 throw new Error("initializeWasm() must be awaited first!");
45365 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_taproot(this_arg);
45366 return nativeResponseValue;
45368 // void InitFeatures_set_onion_messages_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
45370 export function InitFeatures_set_onion_messages_optional(this_arg: bigint): void {
45371 if(!isWasmInitialized) {
45372 throw new Error("initializeWasm() must be awaited first!");
45374 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_optional(this_arg);
45375 // debug statements here
45377 // void InitFeatures_set_onion_messages_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
45379 export function InitFeatures_set_onion_messages_required(this_arg: bigint): void {
45380 if(!isWasmInitialized) {
45381 throw new Error("initializeWasm() must be awaited first!");
45383 const nativeResponseValue = wasm.TS_InitFeatures_set_onion_messages_required(this_arg);
45384 // debug statements here
45386 // MUST_USE_RES bool InitFeatures_supports_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45388 export function InitFeatures_supports_onion_messages(this_arg: bigint): boolean {
45389 if(!isWasmInitialized) {
45390 throw new Error("initializeWasm() must be awaited first!");
45392 const nativeResponseValue = wasm.TS_InitFeatures_supports_onion_messages(this_arg);
45393 return nativeResponseValue;
45395 // void NodeFeatures_set_onion_messages_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45397 export function NodeFeatures_set_onion_messages_optional(this_arg: bigint): void {
45398 if(!isWasmInitialized) {
45399 throw new Error("initializeWasm() must be awaited first!");
45401 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_optional(this_arg);
45402 // debug statements here
45404 // void NodeFeatures_set_onion_messages_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45406 export function NodeFeatures_set_onion_messages_required(this_arg: bigint): void {
45407 if(!isWasmInitialized) {
45408 throw new Error("initializeWasm() must be awaited first!");
45410 const nativeResponseValue = wasm.TS_NodeFeatures_set_onion_messages_required(this_arg);
45411 // debug statements here
45413 // MUST_USE_RES bool NodeFeatures_supports_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45415 export function NodeFeatures_supports_onion_messages(this_arg: bigint): boolean {
45416 if(!isWasmInitialized) {
45417 throw new Error("initializeWasm() must be awaited first!");
45419 const nativeResponseValue = wasm.TS_NodeFeatures_supports_onion_messages(this_arg);
45420 return nativeResponseValue;
45422 // MUST_USE_RES bool InitFeatures_requires_onion_messages(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45424 export function InitFeatures_requires_onion_messages(this_arg: bigint): boolean {
45425 if(!isWasmInitialized) {
45426 throw new Error("initializeWasm() must be awaited first!");
45428 const nativeResponseValue = wasm.TS_InitFeatures_requires_onion_messages(this_arg);
45429 return nativeResponseValue;
45431 // MUST_USE_RES bool NodeFeatures_requires_onion_messages(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45433 export function NodeFeatures_requires_onion_messages(this_arg: bigint): boolean {
45434 if(!isWasmInitialized) {
45435 throw new Error("initializeWasm() must be awaited first!");
45437 const nativeResponseValue = wasm.TS_NodeFeatures_requires_onion_messages(this_arg);
45438 return nativeResponseValue;
45440 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
45442 export function InitFeatures_set_channel_type_optional(this_arg: bigint): void {
45443 if(!isWasmInitialized) {
45444 throw new Error("initializeWasm() must be awaited first!");
45446 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
45447 // debug statements here
45449 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
45451 export function InitFeatures_set_channel_type_required(this_arg: bigint): void {
45452 if(!isWasmInitialized) {
45453 throw new Error("initializeWasm() must be awaited first!");
45455 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
45456 // debug statements here
45458 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45460 export function InitFeatures_supports_channel_type(this_arg: bigint): boolean {
45461 if(!isWasmInitialized) {
45462 throw new Error("initializeWasm() must be awaited first!");
45464 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
45465 return nativeResponseValue;
45467 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45469 export function NodeFeatures_set_channel_type_optional(this_arg: bigint): void {
45470 if(!isWasmInitialized) {
45471 throw new Error("initializeWasm() must be awaited first!");
45473 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
45474 // debug statements here
45476 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45478 export function NodeFeatures_set_channel_type_required(this_arg: bigint): void {
45479 if(!isWasmInitialized) {
45480 throw new Error("initializeWasm() must be awaited first!");
45482 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
45483 // debug statements here
45485 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45487 export function NodeFeatures_supports_channel_type(this_arg: bigint): boolean {
45488 if(!isWasmInitialized) {
45489 throw new Error("initializeWasm() must be awaited first!");
45491 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
45492 return nativeResponseValue;
45494 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45496 export function InitFeatures_requires_channel_type(this_arg: bigint): boolean {
45497 if(!isWasmInitialized) {
45498 throw new Error("initializeWasm() must be awaited first!");
45500 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
45501 return nativeResponseValue;
45503 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45505 export function NodeFeatures_requires_channel_type(this_arg: bigint): boolean {
45506 if(!isWasmInitialized) {
45507 throw new Error("initializeWasm() must be awaited first!");
45509 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
45510 return nativeResponseValue;
45512 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
45514 export function InitFeatures_set_scid_privacy_optional(this_arg: bigint): void {
45515 if(!isWasmInitialized) {
45516 throw new Error("initializeWasm() must be awaited first!");
45518 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
45519 // debug statements here
45521 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
45523 export function InitFeatures_set_scid_privacy_required(this_arg: bigint): void {
45524 if(!isWasmInitialized) {
45525 throw new Error("initializeWasm() must be awaited first!");
45527 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
45528 // debug statements here
45530 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45532 export function InitFeatures_supports_scid_privacy(this_arg: bigint): boolean {
45533 if(!isWasmInitialized) {
45534 throw new Error("initializeWasm() must be awaited first!");
45536 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
45537 return nativeResponseValue;
45539 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45541 export function NodeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
45542 if(!isWasmInitialized) {
45543 throw new Error("initializeWasm() must be awaited first!");
45545 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
45546 // debug statements here
45548 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45550 export function NodeFeatures_set_scid_privacy_required(this_arg: bigint): void {
45551 if(!isWasmInitialized) {
45552 throw new Error("initializeWasm() must be awaited first!");
45554 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
45555 // debug statements here
45557 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45559 export function NodeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
45560 if(!isWasmInitialized) {
45561 throw new Error("initializeWasm() must be awaited first!");
45563 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
45564 return nativeResponseValue;
45566 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45568 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: bigint): void {
45569 if(!isWasmInitialized) {
45570 throw new Error("initializeWasm() must be awaited first!");
45572 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
45573 // debug statements here
45575 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45577 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: bigint): void {
45578 if(!isWasmInitialized) {
45579 throw new Error("initializeWasm() must be awaited first!");
45581 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
45582 // debug statements here
45584 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45586 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: bigint): boolean {
45587 if(!isWasmInitialized) {
45588 throw new Error("initializeWasm() must be awaited first!");
45590 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
45591 return nativeResponseValue;
45593 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45595 export function InitFeatures_requires_scid_privacy(this_arg: bigint): boolean {
45596 if(!isWasmInitialized) {
45597 throw new Error("initializeWasm() must be awaited first!");
45599 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
45600 return nativeResponseValue;
45602 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45604 export function NodeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
45605 if(!isWasmInitialized) {
45606 throw new Error("initializeWasm() must be awaited first!");
45608 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
45609 return nativeResponseValue;
45611 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45613 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: bigint): boolean {
45614 if(!isWasmInitialized) {
45615 throw new Error("initializeWasm() must be awaited first!");
45617 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
45618 return nativeResponseValue;
45620 // void Bolt11InvoiceFeatures_set_payment_metadata_optional(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
45622 export function Bolt11InvoiceFeatures_set_payment_metadata_optional(this_arg: bigint): void {
45623 if(!isWasmInitialized) {
45624 throw new Error("initializeWasm() must be awaited first!");
45626 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_metadata_optional(this_arg);
45627 // debug statements here
45629 // void Bolt11InvoiceFeatures_set_payment_metadata_required(struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
45631 export function Bolt11InvoiceFeatures_set_payment_metadata_required(this_arg: bigint): void {
45632 if(!isWasmInitialized) {
45633 throw new Error("initializeWasm() must be awaited first!");
45635 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_set_payment_metadata_required(this_arg);
45636 // debug statements here
45638 // MUST_USE_RES bool Bolt11InvoiceFeatures_supports_payment_metadata(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
45640 export function Bolt11InvoiceFeatures_supports_payment_metadata(this_arg: bigint): boolean {
45641 if(!isWasmInitialized) {
45642 throw new Error("initializeWasm() must be awaited first!");
45644 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_supports_payment_metadata(this_arg);
45645 return nativeResponseValue;
45647 // MUST_USE_RES bool Bolt11InvoiceFeatures_requires_payment_metadata(const struct LDKBolt11InvoiceFeatures *NONNULL_PTR this_arg);
45649 export function Bolt11InvoiceFeatures_requires_payment_metadata(this_arg: bigint): boolean {
45650 if(!isWasmInitialized) {
45651 throw new Error("initializeWasm() must be awaited first!");
45653 const nativeResponseValue = wasm.TS_Bolt11InvoiceFeatures_requires_payment_metadata(this_arg);
45654 return nativeResponseValue;
45656 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
45658 export function InitFeatures_set_zero_conf_optional(this_arg: bigint): void {
45659 if(!isWasmInitialized) {
45660 throw new Error("initializeWasm() must be awaited first!");
45662 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
45663 // debug statements here
45665 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
45667 export function InitFeatures_set_zero_conf_required(this_arg: bigint): void {
45668 if(!isWasmInitialized) {
45669 throw new Error("initializeWasm() must be awaited first!");
45671 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
45672 // debug statements here
45674 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45676 export function InitFeatures_supports_zero_conf(this_arg: bigint): boolean {
45677 if(!isWasmInitialized) {
45678 throw new Error("initializeWasm() must be awaited first!");
45680 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
45681 return nativeResponseValue;
45683 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45685 export function NodeFeatures_set_zero_conf_optional(this_arg: bigint): void {
45686 if(!isWasmInitialized) {
45687 throw new Error("initializeWasm() must be awaited first!");
45689 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
45690 // debug statements here
45692 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45694 export function NodeFeatures_set_zero_conf_required(this_arg: bigint): void {
45695 if(!isWasmInitialized) {
45696 throw new Error("initializeWasm() must be awaited first!");
45698 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
45699 // debug statements here
45701 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45703 export function NodeFeatures_supports_zero_conf(this_arg: bigint): boolean {
45704 if(!isWasmInitialized) {
45705 throw new Error("initializeWasm() must be awaited first!");
45707 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
45708 return nativeResponseValue;
45710 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45712 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: bigint): void {
45713 if(!isWasmInitialized) {
45714 throw new Error("initializeWasm() must be awaited first!");
45716 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
45717 // debug statements here
45719 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45721 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: bigint): void {
45722 if(!isWasmInitialized) {
45723 throw new Error("initializeWasm() must be awaited first!");
45725 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
45726 // debug statements here
45728 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45730 export function ChannelTypeFeatures_supports_zero_conf(this_arg: bigint): boolean {
45731 if(!isWasmInitialized) {
45732 throw new Error("initializeWasm() must be awaited first!");
45734 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
45735 return nativeResponseValue;
45737 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
45739 export function InitFeatures_requires_zero_conf(this_arg: bigint): boolean {
45740 if(!isWasmInitialized) {
45741 throw new Error("initializeWasm() must be awaited first!");
45743 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
45744 return nativeResponseValue;
45746 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45748 export function NodeFeatures_requires_zero_conf(this_arg: bigint): boolean {
45749 if(!isWasmInitialized) {
45750 throw new Error("initializeWasm() must be awaited first!");
45752 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
45753 return nativeResponseValue;
45755 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
45757 export function ChannelTypeFeatures_requires_zero_conf(this_arg: bigint): boolean {
45758 if(!isWasmInitialized) {
45759 throw new Error("initializeWasm() must be awaited first!");
45761 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
45762 return nativeResponseValue;
45764 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45766 export function NodeFeatures_set_keysend_optional(this_arg: bigint): void {
45767 if(!isWasmInitialized) {
45768 throw new Error("initializeWasm() must be awaited first!");
45770 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
45771 // debug statements here
45773 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
45775 export function NodeFeatures_set_keysend_required(this_arg: bigint): void {
45776 if(!isWasmInitialized) {
45777 throw new Error("initializeWasm() must be awaited first!");
45779 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
45780 // debug statements here
45782 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45784 export function NodeFeatures_supports_keysend(this_arg: bigint): boolean {
45785 if(!isWasmInitialized) {
45786 throw new Error("initializeWasm() must be awaited first!");
45788 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
45789 return nativeResponseValue;
45791 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
45793 export function NodeFeatures_requires_keysend(this_arg: bigint): boolean {
45794 if(!isWasmInitialized) {
45795 throw new Error("initializeWasm() must be awaited first!");
45797 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
45798 return nativeResponseValue;
45800 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
45802 export function ShutdownScript_free(this_obj: bigint): void {
45803 if(!isWasmInitialized) {
45804 throw new Error("initializeWasm() must be awaited first!");
45806 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
45807 // debug statements here
45809 // uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
45811 export function ShutdownScript_clone_ptr(arg: bigint): bigint {
45812 if(!isWasmInitialized) {
45813 throw new Error("initializeWasm() must be awaited first!");
45815 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
45816 return nativeResponseValue;
45818 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
45820 export function ShutdownScript_clone(orig: bigint): bigint {
45821 if(!isWasmInitialized) {
45822 throw new Error("initializeWasm() must be awaited first!");
45824 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
45825 return nativeResponseValue;
45827 // bool ShutdownScript_eq(const struct LDKShutdownScript *NONNULL_PTR a, const struct LDKShutdownScript *NONNULL_PTR b);
45829 export function ShutdownScript_eq(a: bigint, b: bigint): boolean {
45830 if(!isWasmInitialized) {
45831 throw new Error("initializeWasm() must be awaited first!");
45833 const nativeResponseValue = wasm.TS_ShutdownScript_eq(a, b);
45834 return nativeResponseValue;
45836 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
45838 export function InvalidShutdownScript_free(this_obj: bigint): void {
45839 if(!isWasmInitialized) {
45840 throw new Error("initializeWasm() must be awaited first!");
45842 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
45843 // debug statements here
45845 // struct LDKCVec_u8Z InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
45847 export function InvalidShutdownScript_get_script(this_ptr: bigint): number {
45848 if(!isWasmInitialized) {
45849 throw new Error("initializeWasm() must be awaited first!");
45851 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
45852 return nativeResponseValue;
45854 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
45856 export function InvalidShutdownScript_set_script(this_ptr: bigint, val: number): void {
45857 if(!isWasmInitialized) {
45858 throw new Error("initializeWasm() must be awaited first!");
45860 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
45861 // debug statements here
45863 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
45865 export function InvalidShutdownScript_new(script_arg: number): bigint {
45866 if(!isWasmInitialized) {
45867 throw new Error("initializeWasm() must be awaited first!");
45869 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
45870 return nativeResponseValue;
45872 // uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
45874 export function InvalidShutdownScript_clone_ptr(arg: bigint): bigint {
45875 if(!isWasmInitialized) {
45876 throw new Error("initializeWasm() must be awaited first!");
45878 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
45879 return nativeResponseValue;
45881 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
45883 export function InvalidShutdownScript_clone(orig: bigint): bigint {
45884 if(!isWasmInitialized) {
45885 throw new Error("initializeWasm() must be awaited first!");
45887 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
45888 return nativeResponseValue;
45890 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
45892 export function ShutdownScript_write(obj: bigint): number {
45893 if(!isWasmInitialized) {
45894 throw new Error("initializeWasm() must be awaited first!");
45896 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
45897 return nativeResponseValue;
45899 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
45901 export function ShutdownScript_read(ser: number): bigint {
45902 if(!isWasmInitialized) {
45903 throw new Error("initializeWasm() must be awaited first!");
45905 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
45906 return nativeResponseValue;
45908 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
45910 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): bigint {
45911 if(!isWasmInitialized) {
45912 throw new Error("initializeWasm() must be awaited first!");
45914 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
45915 return nativeResponseValue;
45917 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
45919 export function ShutdownScript_new_p2wsh(script_hash: number): bigint {
45920 if(!isWasmInitialized) {
45921 throw new Error("initializeWasm() must be awaited first!");
45923 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
45924 return nativeResponseValue;
45926 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessProgram witness_program);
45928 export function ShutdownScript_new_witness_program(witness_program: bigint): bigint {
45929 if(!isWasmInitialized) {
45930 throw new Error("initializeWasm() must be awaited first!");
45932 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(witness_program);
45933 return nativeResponseValue;
45935 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
45937 export function ShutdownScript_into_inner(this_arg: bigint): number {
45938 if(!isWasmInitialized) {
45939 throw new Error("initializeWasm() must be awaited first!");
45941 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
45942 return nativeResponseValue;
45944 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
45946 export function ShutdownScript_as_legacy_pubkey(this_arg: bigint): number {
45947 if(!isWasmInitialized) {
45948 throw new Error("initializeWasm() must be awaited first!");
45950 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
45951 return nativeResponseValue;
45953 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
45955 export function ShutdownScript_is_compatible(this_arg: bigint, features: bigint): boolean {
45956 if(!isWasmInitialized) {
45957 throw new Error("initializeWasm() must be awaited first!");
45959 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
45960 return nativeResponseValue;
45962 // void Retry_free(struct LDKRetry this_ptr);
45964 export function Retry_free(this_ptr: bigint): void {
45965 if(!isWasmInitialized) {
45966 throw new Error("initializeWasm() must be awaited first!");
45968 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
45969 // debug statements here
45971 // uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
45973 export function Retry_clone_ptr(arg: bigint): bigint {
45974 if(!isWasmInitialized) {
45975 throw new Error("initializeWasm() must be awaited first!");
45977 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
45978 return nativeResponseValue;
45980 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
45982 export function Retry_clone(orig: bigint): bigint {
45983 if(!isWasmInitialized) {
45984 throw new Error("initializeWasm() must be awaited first!");
45986 const nativeResponseValue = wasm.TS_Retry_clone(orig);
45987 return nativeResponseValue;
45989 // struct LDKRetry Retry_attempts(uint32_t a);
45991 export function Retry_attempts(a: number): bigint {
45992 if(!isWasmInitialized) {
45993 throw new Error("initializeWasm() must be awaited first!");
45995 const nativeResponseValue = wasm.TS_Retry_attempts(a);
45996 return nativeResponseValue;
45998 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
46000 export function Retry_eq(a: bigint, b: bigint): boolean {
46001 if(!isWasmInitialized) {
46002 throw new Error("initializeWasm() must be awaited first!");
46004 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
46005 return nativeResponseValue;
46007 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
46009 export function Retry_hash(o: bigint): bigint {
46010 if(!isWasmInitialized) {
46011 throw new Error("initializeWasm() must be awaited first!");
46013 const nativeResponseValue = wasm.TS_Retry_hash(o);
46014 return nativeResponseValue;
46016 // struct LDKCVec_u8Z Retry_write(const struct LDKRetry *NONNULL_PTR obj);
46018 export function Retry_write(obj: bigint): number {
46019 if(!isWasmInitialized) {
46020 throw new Error("initializeWasm() must be awaited first!");
46022 const nativeResponseValue = wasm.TS_Retry_write(obj);
46023 return nativeResponseValue;
46025 // struct LDKCResult_RetryDecodeErrorZ Retry_read(struct LDKu8slice ser);
46027 export function Retry_read(ser: number): bigint {
46028 if(!isWasmInitialized) {
46029 throw new Error("initializeWasm() must be awaited first!");
46031 const nativeResponseValue = wasm.TS_Retry_read(ser);
46032 return nativeResponseValue;
46034 // enum LDKRetryableSendFailure RetryableSendFailure_clone(const enum LDKRetryableSendFailure *NONNULL_PTR orig);
46036 export function RetryableSendFailure_clone(orig: bigint): RetryableSendFailure {
46037 if(!isWasmInitialized) {
46038 throw new Error("initializeWasm() must be awaited first!");
46040 const nativeResponseValue = wasm.TS_RetryableSendFailure_clone(orig);
46041 return nativeResponseValue;
46043 // enum LDKRetryableSendFailure RetryableSendFailure_payment_expired(void);
46045 export function RetryableSendFailure_payment_expired(): RetryableSendFailure {
46046 if(!isWasmInitialized) {
46047 throw new Error("initializeWasm() must be awaited first!");
46049 const nativeResponseValue = wasm.TS_RetryableSendFailure_payment_expired();
46050 return nativeResponseValue;
46052 // enum LDKRetryableSendFailure RetryableSendFailure_route_not_found(void);
46054 export function RetryableSendFailure_route_not_found(): RetryableSendFailure {
46055 if(!isWasmInitialized) {
46056 throw new Error("initializeWasm() must be awaited first!");
46058 const nativeResponseValue = wasm.TS_RetryableSendFailure_route_not_found();
46059 return nativeResponseValue;
46061 // enum LDKRetryableSendFailure RetryableSendFailure_duplicate_payment(void);
46063 export function RetryableSendFailure_duplicate_payment(): RetryableSendFailure {
46064 if(!isWasmInitialized) {
46065 throw new Error("initializeWasm() must be awaited first!");
46067 const nativeResponseValue = wasm.TS_RetryableSendFailure_duplicate_payment();
46068 return nativeResponseValue;
46070 // bool RetryableSendFailure_eq(const enum LDKRetryableSendFailure *NONNULL_PTR a, const enum LDKRetryableSendFailure *NONNULL_PTR b);
46072 export function RetryableSendFailure_eq(a: bigint, b: bigint): boolean {
46073 if(!isWasmInitialized) {
46074 throw new Error("initializeWasm() must be awaited first!");
46076 const nativeResponseValue = wasm.TS_RetryableSendFailure_eq(a, b);
46077 return nativeResponseValue;
46079 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
46081 export function PaymentSendFailure_free(this_ptr: bigint): void {
46082 if(!isWasmInitialized) {
46083 throw new Error("initializeWasm() must be awaited first!");
46085 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
46086 // debug statements here
46088 // uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
46090 export function PaymentSendFailure_clone_ptr(arg: bigint): bigint {
46091 if(!isWasmInitialized) {
46092 throw new Error("initializeWasm() must be awaited first!");
46094 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
46095 return nativeResponseValue;
46097 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
46099 export function PaymentSendFailure_clone(orig: bigint): bigint {
46100 if(!isWasmInitialized) {
46101 throw new Error("initializeWasm() must be awaited first!");
46103 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
46104 return nativeResponseValue;
46106 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
46108 export function PaymentSendFailure_parameter_error(a: bigint): bigint {
46109 if(!isWasmInitialized) {
46110 throw new Error("initializeWasm() must be awaited first!");
46112 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
46113 return nativeResponseValue;
46115 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
46117 export function PaymentSendFailure_path_parameter_error(a: number): bigint {
46118 if(!isWasmInitialized) {
46119 throw new Error("initializeWasm() must be awaited first!");
46121 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
46122 return nativeResponseValue;
46124 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_resend_safe(struct LDKCVec_APIErrorZ a);
46126 export function PaymentSendFailure_all_failed_resend_safe(a: number): bigint {
46127 if(!isWasmInitialized) {
46128 throw new Error("initializeWasm() must be awaited first!");
46130 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_resend_safe(a);
46131 return nativeResponseValue;
46133 // struct LDKPaymentSendFailure PaymentSendFailure_duplicate_payment(void);
46135 export function PaymentSendFailure_duplicate_payment(): bigint {
46136 if(!isWasmInitialized) {
46137 throw new Error("initializeWasm() must be awaited first!");
46139 const nativeResponseValue = wasm.TS_PaymentSendFailure_duplicate_payment();
46140 return nativeResponseValue;
46142 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
46144 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: bigint, payment_id: number): bigint {
46145 if(!isWasmInitialized) {
46146 throw new Error("initializeWasm() must be awaited first!");
46148 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
46149 return nativeResponseValue;
46151 // bool PaymentSendFailure_eq(const struct LDKPaymentSendFailure *NONNULL_PTR a, const struct LDKPaymentSendFailure *NONNULL_PTR b);
46153 export function PaymentSendFailure_eq(a: bigint, b: bigint): boolean {
46154 if(!isWasmInitialized) {
46155 throw new Error("initializeWasm() must be awaited first!");
46157 const nativeResponseValue = wasm.TS_PaymentSendFailure_eq(a, b);
46158 return nativeResponseValue;
46160 // void ProbeSendFailure_free(struct LDKProbeSendFailure this_ptr);
46162 export function ProbeSendFailure_free(this_ptr: bigint): void {
46163 if(!isWasmInitialized) {
46164 throw new Error("initializeWasm() must be awaited first!");
46166 const nativeResponseValue = wasm.TS_ProbeSendFailure_free(this_ptr);
46167 // debug statements here
46169 // uint64_t ProbeSendFailure_clone_ptr(LDKProbeSendFailure *NONNULL_PTR arg);
46171 export function ProbeSendFailure_clone_ptr(arg: bigint): bigint {
46172 if(!isWasmInitialized) {
46173 throw new Error("initializeWasm() must be awaited first!");
46175 const nativeResponseValue = wasm.TS_ProbeSendFailure_clone_ptr(arg);
46176 return nativeResponseValue;
46178 // struct LDKProbeSendFailure ProbeSendFailure_clone(const struct LDKProbeSendFailure *NONNULL_PTR orig);
46180 export function ProbeSendFailure_clone(orig: bigint): bigint {
46181 if(!isWasmInitialized) {
46182 throw new Error("initializeWasm() must be awaited first!");
46184 const nativeResponseValue = wasm.TS_ProbeSendFailure_clone(orig);
46185 return nativeResponseValue;
46187 // struct LDKProbeSendFailure ProbeSendFailure_route_not_found(void);
46189 export function ProbeSendFailure_route_not_found(): bigint {
46190 if(!isWasmInitialized) {
46191 throw new Error("initializeWasm() must be awaited first!");
46193 const nativeResponseValue = wasm.TS_ProbeSendFailure_route_not_found();
46194 return nativeResponseValue;
46196 // struct LDKProbeSendFailure ProbeSendFailure_sending_failed(struct LDKPaymentSendFailure a);
46198 export function ProbeSendFailure_sending_failed(a: bigint): bigint {
46199 if(!isWasmInitialized) {
46200 throw new Error("initializeWasm() must be awaited first!");
46202 const nativeResponseValue = wasm.TS_ProbeSendFailure_sending_failed(a);
46203 return nativeResponseValue;
46205 // bool ProbeSendFailure_eq(const struct LDKProbeSendFailure *NONNULL_PTR a, const struct LDKProbeSendFailure *NONNULL_PTR b);
46207 export function ProbeSendFailure_eq(a: bigint, b: bigint): boolean {
46208 if(!isWasmInitialized) {
46209 throw new Error("initializeWasm() must be awaited first!");
46211 const nativeResponseValue = wasm.TS_ProbeSendFailure_eq(a, b);
46212 return nativeResponseValue;
46214 // void RecipientOnionFields_free(struct LDKRecipientOnionFields this_obj);
46216 export function RecipientOnionFields_free(this_obj: bigint): void {
46217 if(!isWasmInitialized) {
46218 throw new Error("initializeWasm() must be awaited first!");
46220 const nativeResponseValue = wasm.TS_RecipientOnionFields_free(this_obj);
46221 // debug statements here
46223 // struct LDKCOption_ThirtyTwoBytesZ RecipientOnionFields_get_payment_secret(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
46225 export function RecipientOnionFields_get_payment_secret(this_ptr: bigint): bigint {
46226 if(!isWasmInitialized) {
46227 throw new Error("initializeWasm() must be awaited first!");
46229 const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_secret(this_ptr);
46230 return nativeResponseValue;
46232 // void RecipientOnionFields_set_payment_secret(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
46234 export function RecipientOnionFields_set_payment_secret(this_ptr: bigint, val: bigint): void {
46235 if(!isWasmInitialized) {
46236 throw new Error("initializeWasm() must be awaited first!");
46238 const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_secret(this_ptr, val);
46239 // debug statements here
46241 // struct LDKCOption_CVec_u8ZZ RecipientOnionFields_get_payment_metadata(const struct LDKRecipientOnionFields *NONNULL_PTR this_ptr);
46243 export function RecipientOnionFields_get_payment_metadata(this_ptr: bigint): bigint {
46244 if(!isWasmInitialized) {
46245 throw new Error("initializeWasm() must be awaited first!");
46247 const nativeResponseValue = wasm.TS_RecipientOnionFields_get_payment_metadata(this_ptr);
46248 return nativeResponseValue;
46250 // void RecipientOnionFields_set_payment_metadata(struct LDKRecipientOnionFields *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
46252 export function RecipientOnionFields_set_payment_metadata(this_ptr: bigint, val: bigint): void {
46253 if(!isWasmInitialized) {
46254 throw new Error("initializeWasm() must be awaited first!");
46256 const nativeResponseValue = wasm.TS_RecipientOnionFields_set_payment_metadata(this_ptr, val);
46257 // debug statements here
46259 // uint64_t RecipientOnionFields_clone_ptr(LDKRecipientOnionFields *NONNULL_PTR arg);
46261 export function RecipientOnionFields_clone_ptr(arg: bigint): bigint {
46262 if(!isWasmInitialized) {
46263 throw new Error("initializeWasm() must be awaited first!");
46265 const nativeResponseValue = wasm.TS_RecipientOnionFields_clone_ptr(arg);
46266 return nativeResponseValue;
46268 // struct LDKRecipientOnionFields RecipientOnionFields_clone(const struct LDKRecipientOnionFields *NONNULL_PTR orig);
46270 export function RecipientOnionFields_clone(orig: bigint): bigint {
46271 if(!isWasmInitialized) {
46272 throw new Error("initializeWasm() must be awaited first!");
46274 const nativeResponseValue = wasm.TS_RecipientOnionFields_clone(orig);
46275 return nativeResponseValue;
46277 // bool RecipientOnionFields_eq(const struct LDKRecipientOnionFields *NONNULL_PTR a, const struct LDKRecipientOnionFields *NONNULL_PTR b);
46279 export function RecipientOnionFields_eq(a: bigint, b: bigint): boolean {
46280 if(!isWasmInitialized) {
46281 throw new Error("initializeWasm() must be awaited first!");
46283 const nativeResponseValue = wasm.TS_RecipientOnionFields_eq(a, b);
46284 return nativeResponseValue;
46286 // struct LDKCVec_u8Z RecipientOnionFields_write(const struct LDKRecipientOnionFields *NONNULL_PTR obj);
46288 export function RecipientOnionFields_write(obj: bigint): number {
46289 if(!isWasmInitialized) {
46290 throw new Error("initializeWasm() must be awaited first!");
46292 const nativeResponseValue = wasm.TS_RecipientOnionFields_write(obj);
46293 return nativeResponseValue;
46295 // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ RecipientOnionFields_read(struct LDKu8slice ser);
46297 export function RecipientOnionFields_read(ser: number): bigint {
46298 if(!isWasmInitialized) {
46299 throw new Error("initializeWasm() must be awaited first!");
46301 const nativeResponseValue = wasm.TS_RecipientOnionFields_read(ser);
46302 return nativeResponseValue;
46304 // MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_secret_only(struct LDKThirtyTwoBytes payment_secret);
46306 export function RecipientOnionFields_secret_only(payment_secret: number): bigint {
46307 if(!isWasmInitialized) {
46308 throw new Error("initializeWasm() must be awaited first!");
46310 const nativeResponseValue = wasm.TS_RecipientOnionFields_secret_only(payment_secret);
46311 return nativeResponseValue;
46313 // MUST_USE_RES struct LDKRecipientOnionFields RecipientOnionFields_spontaneous_empty(void);
46315 export function RecipientOnionFields_spontaneous_empty(): bigint {
46316 if(!isWasmInitialized) {
46317 throw new Error("initializeWasm() must be awaited first!");
46319 const nativeResponseValue = wasm.TS_RecipientOnionFields_spontaneous_empty();
46320 return nativeResponseValue;
46322 // MUST_USE_RES struct LDKCResult_RecipientOnionFieldsNoneZ RecipientOnionFields_with_custom_tlvs(struct LDKRecipientOnionFields this_arg, struct LDKCVec_C2Tuple_u64CVec_u8ZZZ custom_tlvs);
46324 export function RecipientOnionFields_with_custom_tlvs(this_arg: bigint, custom_tlvs: number): bigint {
46325 if(!isWasmInitialized) {
46326 throw new Error("initializeWasm() must be awaited first!");
46328 const nativeResponseValue = wasm.TS_RecipientOnionFields_with_custom_tlvs(this_arg, custom_tlvs);
46329 return nativeResponseValue;
46331 // MUST_USE_RES struct LDKCVec_C2Tuple_u64CVec_u8ZZZ RecipientOnionFields_custom_tlvs(const struct LDKRecipientOnionFields *NONNULL_PTR this_arg);
46333 export function RecipientOnionFields_custom_tlvs(this_arg: bigint): number {
46334 if(!isWasmInitialized) {
46335 throw new Error("initializeWasm() must be awaited first!");
46337 const nativeResponseValue = wasm.TS_RecipientOnionFields_custom_tlvs(this_arg);
46338 return nativeResponseValue;
46340 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
46342 export function CustomMessageReader_free(this_ptr: bigint): void {
46343 if(!isWasmInitialized) {
46344 throw new Error("initializeWasm() must be awaited first!");
46346 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
46347 // debug statements here
46349 // uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
46351 export function Type_clone_ptr(arg: bigint): bigint {
46352 if(!isWasmInitialized) {
46353 throw new Error("initializeWasm() must be awaited first!");
46355 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
46356 return nativeResponseValue;
46358 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
46360 export function Type_clone(orig: bigint): bigint {
46361 if(!isWasmInitialized) {
46362 throw new Error("initializeWasm() must be awaited first!");
46364 const nativeResponseValue = wasm.TS_Type_clone(orig);
46365 return nativeResponseValue;
46367 // void Type_free(struct LDKType this_ptr);
46369 export function Type_free(this_ptr: bigint): void {
46370 if(!isWasmInitialized) {
46371 throw new Error("initializeWasm() must be awaited first!");
46373 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
46374 // debug statements here
46376 // void Offer_free(struct LDKOffer this_obj);
46378 export function Offer_free(this_obj: bigint): void {
46379 if(!isWasmInitialized) {
46380 throw new Error("initializeWasm() must be awaited first!");
46382 const nativeResponseValue = wasm.TS_Offer_free(this_obj);
46383 // debug statements here
46385 // uint64_t Offer_clone_ptr(LDKOffer *NONNULL_PTR arg);
46387 export function Offer_clone_ptr(arg: bigint): bigint {
46388 if(!isWasmInitialized) {
46389 throw new Error("initializeWasm() must be awaited first!");
46391 const nativeResponseValue = wasm.TS_Offer_clone_ptr(arg);
46392 return nativeResponseValue;
46394 // struct LDKOffer Offer_clone(const struct LDKOffer *NONNULL_PTR orig);
46396 export function Offer_clone(orig: bigint): bigint {
46397 if(!isWasmInitialized) {
46398 throw new Error("initializeWasm() must be awaited first!");
46400 const nativeResponseValue = wasm.TS_Offer_clone(orig);
46401 return nativeResponseValue;
46403 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ Offer_chains(const struct LDKOffer *NONNULL_PTR this_arg);
46405 export function Offer_chains(this_arg: bigint): number {
46406 if(!isWasmInitialized) {
46407 throw new Error("initializeWasm() must be awaited first!");
46409 const nativeResponseValue = wasm.TS_Offer_chains(this_arg);
46410 return nativeResponseValue;
46412 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Offer_metadata(const struct LDKOffer *NONNULL_PTR this_arg);
46414 export function Offer_metadata(this_arg: bigint): bigint {
46415 if(!isWasmInitialized) {
46416 throw new Error("initializeWasm() must be awaited first!");
46418 const nativeResponseValue = wasm.TS_Offer_metadata(this_arg);
46419 return nativeResponseValue;
46421 // MUST_USE_RES struct LDKAmount Offer_amount(const struct LDKOffer *NONNULL_PTR this_arg);
46423 export function Offer_amount(this_arg: bigint): bigint {
46424 if(!isWasmInitialized) {
46425 throw new Error("initializeWasm() must be awaited first!");
46427 const nativeResponseValue = wasm.TS_Offer_amount(this_arg);
46428 return nativeResponseValue;
46430 // MUST_USE_RES struct LDKPrintableString Offer_description(const struct LDKOffer *NONNULL_PTR this_arg);
46432 export function Offer_description(this_arg: bigint): bigint {
46433 if(!isWasmInitialized) {
46434 throw new Error("initializeWasm() must be awaited first!");
46436 const nativeResponseValue = wasm.TS_Offer_description(this_arg);
46437 return nativeResponseValue;
46439 // MUST_USE_RES struct LDKOfferFeatures Offer_offer_features(const struct LDKOffer *NONNULL_PTR this_arg);
46441 export function Offer_offer_features(this_arg: bigint): bigint {
46442 if(!isWasmInitialized) {
46443 throw new Error("initializeWasm() must be awaited first!");
46445 const nativeResponseValue = wasm.TS_Offer_offer_features(this_arg);
46446 return nativeResponseValue;
46448 // MUST_USE_RES struct LDKCOption_u64Z Offer_absolute_expiry(const struct LDKOffer *NONNULL_PTR this_arg);
46450 export function Offer_absolute_expiry(this_arg: bigint): bigint {
46451 if(!isWasmInitialized) {
46452 throw new Error("initializeWasm() must be awaited first!");
46454 const nativeResponseValue = wasm.TS_Offer_absolute_expiry(this_arg);
46455 return nativeResponseValue;
46457 // MUST_USE_RES struct LDKPrintableString Offer_issuer(const struct LDKOffer *NONNULL_PTR this_arg);
46459 export function Offer_issuer(this_arg: bigint): bigint {
46460 if(!isWasmInitialized) {
46461 throw new Error("initializeWasm() must be awaited first!");
46463 const nativeResponseValue = wasm.TS_Offer_issuer(this_arg);
46464 return nativeResponseValue;
46466 // MUST_USE_RES struct LDKCVec_BlindedPathZ Offer_paths(const struct LDKOffer *NONNULL_PTR this_arg);
46468 export function Offer_paths(this_arg: bigint): number {
46469 if(!isWasmInitialized) {
46470 throw new Error("initializeWasm() must be awaited first!");
46472 const nativeResponseValue = wasm.TS_Offer_paths(this_arg);
46473 return nativeResponseValue;
46475 // MUST_USE_RES struct LDKQuantity Offer_supported_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
46477 export function Offer_supported_quantity(this_arg: bigint): bigint {
46478 if(!isWasmInitialized) {
46479 throw new Error("initializeWasm() must be awaited first!");
46481 const nativeResponseValue = wasm.TS_Offer_supported_quantity(this_arg);
46482 return nativeResponseValue;
46484 // MUST_USE_RES struct LDKPublicKey Offer_signing_pubkey(const struct LDKOffer *NONNULL_PTR this_arg);
46486 export function Offer_signing_pubkey(this_arg: bigint): number {
46487 if(!isWasmInitialized) {
46488 throw new Error("initializeWasm() must be awaited first!");
46490 const nativeResponseValue = wasm.TS_Offer_signing_pubkey(this_arg);
46491 return nativeResponseValue;
46493 // MUST_USE_RES bool Offer_supports_chain(const struct LDKOffer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes chain);
46495 export function Offer_supports_chain(this_arg: bigint, chain: number): boolean {
46496 if(!isWasmInitialized) {
46497 throw new Error("initializeWasm() must be awaited first!");
46499 const nativeResponseValue = wasm.TS_Offer_supports_chain(this_arg, chain);
46500 return nativeResponseValue;
46502 // MUST_USE_RES bool Offer_is_expired_no_std(const struct LDKOffer *NONNULL_PTR this_arg, uint64_t duration_since_epoch);
46504 export function Offer_is_expired_no_std(this_arg: bigint, duration_since_epoch: bigint): boolean {
46505 if(!isWasmInitialized) {
46506 throw new Error("initializeWasm() must be awaited first!");
46508 const nativeResponseValue = wasm.TS_Offer_is_expired_no_std(this_arg, duration_since_epoch);
46509 return nativeResponseValue;
46511 // MUST_USE_RES bool Offer_is_valid_quantity(const struct LDKOffer *NONNULL_PTR this_arg, uint64_t quantity);
46513 export function Offer_is_valid_quantity(this_arg: bigint, quantity: bigint): boolean {
46514 if(!isWasmInitialized) {
46515 throw new Error("initializeWasm() must be awaited first!");
46517 const nativeResponseValue = wasm.TS_Offer_is_valid_quantity(this_arg, quantity);
46518 return nativeResponseValue;
46520 // MUST_USE_RES bool Offer_expects_quantity(const struct LDKOffer *NONNULL_PTR this_arg);
46522 export function Offer_expects_quantity(this_arg: bigint): boolean {
46523 if(!isWasmInitialized) {
46524 throw new Error("initializeWasm() must be awaited first!");
46526 const nativeResponseValue = wasm.TS_Offer_expects_quantity(this_arg);
46527 return nativeResponseValue;
46529 // struct LDKCVec_u8Z Offer_write(const struct LDKOffer *NONNULL_PTR obj);
46531 export function Offer_write(obj: bigint): number {
46532 if(!isWasmInitialized) {
46533 throw new Error("initializeWasm() must be awaited first!");
46535 const nativeResponseValue = wasm.TS_Offer_write(obj);
46536 return nativeResponseValue;
46538 // void Amount_free(struct LDKAmount this_obj);
46540 export function Amount_free(this_obj: bigint): void {
46541 if(!isWasmInitialized) {
46542 throw new Error("initializeWasm() must be awaited first!");
46544 const nativeResponseValue = wasm.TS_Amount_free(this_obj);
46545 // debug statements here
46547 // uint64_t Amount_clone_ptr(LDKAmount *NONNULL_PTR arg);
46549 export function Amount_clone_ptr(arg: bigint): bigint {
46550 if(!isWasmInitialized) {
46551 throw new Error("initializeWasm() must be awaited first!");
46553 const nativeResponseValue = wasm.TS_Amount_clone_ptr(arg);
46554 return nativeResponseValue;
46556 // struct LDKAmount Amount_clone(const struct LDKAmount *NONNULL_PTR orig);
46558 export function Amount_clone(orig: bigint): bigint {
46559 if(!isWasmInitialized) {
46560 throw new Error("initializeWasm() must be awaited first!");
46562 const nativeResponseValue = wasm.TS_Amount_clone(orig);
46563 return nativeResponseValue;
46565 // void Quantity_free(struct LDKQuantity this_obj);
46567 export function Quantity_free(this_obj: bigint): void {
46568 if(!isWasmInitialized) {
46569 throw new Error("initializeWasm() must be awaited first!");
46571 const nativeResponseValue = wasm.TS_Quantity_free(this_obj);
46572 // debug statements here
46574 // uint64_t Quantity_clone_ptr(LDKQuantity *NONNULL_PTR arg);
46576 export function Quantity_clone_ptr(arg: bigint): bigint {
46577 if(!isWasmInitialized) {
46578 throw new Error("initializeWasm() must be awaited first!");
46580 const nativeResponseValue = wasm.TS_Quantity_clone_ptr(arg);
46581 return nativeResponseValue;
46583 // struct LDKQuantity Quantity_clone(const struct LDKQuantity *NONNULL_PTR orig);
46585 export function Quantity_clone(orig: bigint): bigint {
46586 if(!isWasmInitialized) {
46587 throw new Error("initializeWasm() must be awaited first!");
46589 const nativeResponseValue = wasm.TS_Quantity_clone(orig);
46590 return nativeResponseValue;
46592 // struct LDKCResult_OfferBolt12ParseErrorZ Offer_from_str(struct LDKStr s);
46594 export function Offer_from_str(s: number): bigint {
46595 if(!isWasmInitialized) {
46596 throw new Error("initializeWasm() must be awaited first!");
46598 const nativeResponseValue = wasm.TS_Offer_from_str(s);
46599 return nativeResponseValue;
46601 // void UnsignedBolt12Invoice_free(struct LDKUnsignedBolt12Invoice this_obj);
46603 export function UnsignedBolt12Invoice_free(this_obj: bigint): void {
46604 if(!isWasmInitialized) {
46605 throw new Error("initializeWasm() must be awaited first!");
46607 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_free(this_obj);
46608 // debug statements here
46610 // MUST_USE_RES struct LDKTaggedHash UnsignedBolt12Invoice_tagged_hash(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46612 export function UnsignedBolt12Invoice_tagged_hash(this_arg: bigint): bigint {
46613 if(!isWasmInitialized) {
46614 throw new Error("initializeWasm() must be awaited first!");
46616 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_tagged_hash(this_arg);
46617 return nativeResponseValue;
46619 // void Bolt12Invoice_free(struct LDKBolt12Invoice this_obj);
46621 export function Bolt12Invoice_free(this_obj: bigint): void {
46622 if(!isWasmInitialized) {
46623 throw new Error("initializeWasm() must be awaited first!");
46625 const nativeResponseValue = wasm.TS_Bolt12Invoice_free(this_obj);
46626 // debug statements here
46628 // uint64_t Bolt12Invoice_clone_ptr(LDKBolt12Invoice *NONNULL_PTR arg);
46630 export function Bolt12Invoice_clone_ptr(arg: bigint): bigint {
46631 if(!isWasmInitialized) {
46632 throw new Error("initializeWasm() must be awaited first!");
46634 const nativeResponseValue = wasm.TS_Bolt12Invoice_clone_ptr(arg);
46635 return nativeResponseValue;
46637 // struct LDKBolt12Invoice Bolt12Invoice_clone(const struct LDKBolt12Invoice *NONNULL_PTR orig);
46639 export function Bolt12Invoice_clone(orig: bigint): bigint {
46640 if(!isWasmInitialized) {
46641 throw new Error("initializeWasm() must be awaited first!");
46643 const nativeResponseValue = wasm.TS_Bolt12Invoice_clone(orig);
46644 return nativeResponseValue;
46646 // MUST_USE_RES struct LDKCOption_CVec_ThirtyTwoBytesZZ UnsignedBolt12Invoice_offer_chains(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46648 export function UnsignedBolt12Invoice_offer_chains(this_arg: bigint): bigint {
46649 if(!isWasmInitialized) {
46650 throw new Error("initializeWasm() must be awaited first!");
46652 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_offer_chains(this_arg);
46653 return nativeResponseValue;
46655 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedBolt12Invoice_chain(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46657 export function UnsignedBolt12Invoice_chain(this_arg: bigint): number {
46658 if(!isWasmInitialized) {
46659 throw new Error("initializeWasm() must be awaited first!");
46661 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_chain(this_arg);
46662 return nativeResponseValue;
46664 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ UnsignedBolt12Invoice_metadata(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46666 export function UnsignedBolt12Invoice_metadata(this_arg: bigint): bigint {
46667 if(!isWasmInitialized) {
46668 throw new Error("initializeWasm() must be awaited first!");
46670 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_metadata(this_arg);
46671 return nativeResponseValue;
46673 // MUST_USE_RES struct LDKAmount UnsignedBolt12Invoice_amount(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46675 export function UnsignedBolt12Invoice_amount(this_arg: bigint): bigint {
46676 if(!isWasmInitialized) {
46677 throw new Error("initializeWasm() must be awaited first!");
46679 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_amount(this_arg);
46680 return nativeResponseValue;
46682 // MUST_USE_RES struct LDKOfferFeatures UnsignedBolt12Invoice_offer_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46684 export function UnsignedBolt12Invoice_offer_features(this_arg: bigint): bigint {
46685 if(!isWasmInitialized) {
46686 throw new Error("initializeWasm() must be awaited first!");
46688 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_offer_features(this_arg);
46689 return nativeResponseValue;
46691 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_description(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46693 export function UnsignedBolt12Invoice_description(this_arg: bigint): bigint {
46694 if(!isWasmInitialized) {
46695 throw new Error("initializeWasm() must be awaited first!");
46697 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_description(this_arg);
46698 return nativeResponseValue;
46700 // MUST_USE_RES struct LDKCOption_u64Z UnsignedBolt12Invoice_absolute_expiry(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46702 export function UnsignedBolt12Invoice_absolute_expiry(this_arg: bigint): bigint {
46703 if(!isWasmInitialized) {
46704 throw new Error("initializeWasm() must be awaited first!");
46706 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_absolute_expiry(this_arg);
46707 return nativeResponseValue;
46709 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_issuer(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46711 export function UnsignedBolt12Invoice_issuer(this_arg: bigint): bigint {
46712 if(!isWasmInitialized) {
46713 throw new Error("initializeWasm() must be awaited first!");
46715 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_issuer(this_arg);
46716 return nativeResponseValue;
46718 // MUST_USE_RES struct LDKCVec_BlindedPathZ UnsignedBolt12Invoice_message_paths(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46720 export function UnsignedBolt12Invoice_message_paths(this_arg: bigint): number {
46721 if(!isWasmInitialized) {
46722 throw new Error("initializeWasm() must be awaited first!");
46724 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_message_paths(this_arg);
46725 return nativeResponseValue;
46727 // MUST_USE_RES struct LDKQuantity UnsignedBolt12Invoice_supported_quantity(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46729 export function UnsignedBolt12Invoice_supported_quantity(this_arg: bigint): bigint {
46730 if(!isWasmInitialized) {
46731 throw new Error("initializeWasm() must be awaited first!");
46733 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_supported_quantity(this_arg);
46734 return nativeResponseValue;
46736 // MUST_USE_RES struct LDKu8slice UnsignedBolt12Invoice_payer_metadata(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46738 export function UnsignedBolt12Invoice_payer_metadata(this_arg: bigint): number {
46739 if(!isWasmInitialized) {
46740 throw new Error("initializeWasm() must be awaited first!");
46742 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_metadata(this_arg);
46743 return nativeResponseValue;
46745 // MUST_USE_RES struct LDKInvoiceRequestFeatures UnsignedBolt12Invoice_invoice_request_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46747 export function UnsignedBolt12Invoice_invoice_request_features(this_arg: bigint): bigint {
46748 if(!isWasmInitialized) {
46749 throw new Error("initializeWasm() must be awaited first!");
46751 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_invoice_request_features(this_arg);
46752 return nativeResponseValue;
46754 // MUST_USE_RES struct LDKCOption_u64Z UnsignedBolt12Invoice_quantity(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46756 export function UnsignedBolt12Invoice_quantity(this_arg: bigint): bigint {
46757 if(!isWasmInitialized) {
46758 throw new Error("initializeWasm() must be awaited first!");
46760 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_quantity(this_arg);
46761 return nativeResponseValue;
46763 // MUST_USE_RES struct LDKPublicKey UnsignedBolt12Invoice_payer_id(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46765 export function UnsignedBolt12Invoice_payer_id(this_arg: bigint): number {
46766 if(!isWasmInitialized) {
46767 throw new Error("initializeWasm() must be awaited first!");
46769 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_id(this_arg);
46770 return nativeResponseValue;
46772 // MUST_USE_RES struct LDKPrintableString UnsignedBolt12Invoice_payer_note(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46774 export function UnsignedBolt12Invoice_payer_note(this_arg: bigint): bigint {
46775 if(!isWasmInitialized) {
46776 throw new Error("initializeWasm() must be awaited first!");
46778 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payer_note(this_arg);
46779 return nativeResponseValue;
46781 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_created_at(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46783 export function UnsignedBolt12Invoice_created_at(this_arg: bigint): bigint {
46784 if(!isWasmInitialized) {
46785 throw new Error("initializeWasm() must be awaited first!");
46787 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_created_at(this_arg);
46788 return nativeResponseValue;
46790 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_relative_expiry(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46792 export function UnsignedBolt12Invoice_relative_expiry(this_arg: bigint): bigint {
46793 if(!isWasmInitialized) {
46794 throw new Error("initializeWasm() must be awaited first!");
46796 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_relative_expiry(this_arg);
46797 return nativeResponseValue;
46799 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedBolt12Invoice_payment_hash(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46801 export function UnsignedBolt12Invoice_payment_hash(this_arg: bigint): number {
46802 if(!isWasmInitialized) {
46803 throw new Error("initializeWasm() must be awaited first!");
46805 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_payment_hash(this_arg);
46806 return nativeResponseValue;
46808 // MUST_USE_RES uint64_t UnsignedBolt12Invoice_amount_msats(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46810 export function UnsignedBolt12Invoice_amount_msats(this_arg: bigint): bigint {
46811 if(!isWasmInitialized) {
46812 throw new Error("initializeWasm() must be awaited first!");
46814 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_amount_msats(this_arg);
46815 return nativeResponseValue;
46817 // MUST_USE_RES struct LDKBolt12InvoiceFeatures UnsignedBolt12Invoice_invoice_features(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46819 export function UnsignedBolt12Invoice_invoice_features(this_arg: bigint): bigint {
46820 if(!isWasmInitialized) {
46821 throw new Error("initializeWasm() must be awaited first!");
46823 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_invoice_features(this_arg);
46824 return nativeResponseValue;
46826 // MUST_USE_RES struct LDKPublicKey UnsignedBolt12Invoice_signing_pubkey(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR this_arg);
46828 export function UnsignedBolt12Invoice_signing_pubkey(this_arg: bigint): number {
46829 if(!isWasmInitialized) {
46830 throw new Error("initializeWasm() must be awaited first!");
46832 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_signing_pubkey(this_arg);
46833 return nativeResponseValue;
46835 // MUST_USE_RES struct LDKCOption_CVec_ThirtyTwoBytesZZ Bolt12Invoice_offer_chains(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46837 export function Bolt12Invoice_offer_chains(this_arg: bigint): bigint {
46838 if(!isWasmInitialized) {
46839 throw new Error("initializeWasm() must be awaited first!");
46841 const nativeResponseValue = wasm.TS_Bolt12Invoice_offer_chains(this_arg);
46842 return nativeResponseValue;
46844 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_chain(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46846 export function Bolt12Invoice_chain(this_arg: bigint): number {
46847 if(!isWasmInitialized) {
46848 throw new Error("initializeWasm() must be awaited first!");
46850 const nativeResponseValue = wasm.TS_Bolt12Invoice_chain(this_arg);
46851 return nativeResponseValue;
46853 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Bolt12Invoice_metadata(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46855 export function Bolt12Invoice_metadata(this_arg: bigint): bigint {
46856 if(!isWasmInitialized) {
46857 throw new Error("initializeWasm() must be awaited first!");
46859 const nativeResponseValue = wasm.TS_Bolt12Invoice_metadata(this_arg);
46860 return nativeResponseValue;
46862 // MUST_USE_RES struct LDKAmount Bolt12Invoice_amount(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46864 export function Bolt12Invoice_amount(this_arg: bigint): bigint {
46865 if(!isWasmInitialized) {
46866 throw new Error("initializeWasm() must be awaited first!");
46868 const nativeResponseValue = wasm.TS_Bolt12Invoice_amount(this_arg);
46869 return nativeResponseValue;
46871 // MUST_USE_RES struct LDKOfferFeatures Bolt12Invoice_offer_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46873 export function Bolt12Invoice_offer_features(this_arg: bigint): bigint {
46874 if(!isWasmInitialized) {
46875 throw new Error("initializeWasm() must be awaited first!");
46877 const nativeResponseValue = wasm.TS_Bolt12Invoice_offer_features(this_arg);
46878 return nativeResponseValue;
46880 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_description(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46882 export function Bolt12Invoice_description(this_arg: bigint): bigint {
46883 if(!isWasmInitialized) {
46884 throw new Error("initializeWasm() must be awaited first!");
46886 const nativeResponseValue = wasm.TS_Bolt12Invoice_description(this_arg);
46887 return nativeResponseValue;
46889 // MUST_USE_RES struct LDKCOption_u64Z Bolt12Invoice_absolute_expiry(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46891 export function Bolt12Invoice_absolute_expiry(this_arg: bigint): bigint {
46892 if(!isWasmInitialized) {
46893 throw new Error("initializeWasm() must be awaited first!");
46895 const nativeResponseValue = wasm.TS_Bolt12Invoice_absolute_expiry(this_arg);
46896 return nativeResponseValue;
46898 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_issuer(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46900 export function Bolt12Invoice_issuer(this_arg: bigint): bigint {
46901 if(!isWasmInitialized) {
46902 throw new Error("initializeWasm() must be awaited first!");
46904 const nativeResponseValue = wasm.TS_Bolt12Invoice_issuer(this_arg);
46905 return nativeResponseValue;
46907 // MUST_USE_RES struct LDKCVec_BlindedPathZ Bolt12Invoice_message_paths(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46909 export function Bolt12Invoice_message_paths(this_arg: bigint): number {
46910 if(!isWasmInitialized) {
46911 throw new Error("initializeWasm() must be awaited first!");
46913 const nativeResponseValue = wasm.TS_Bolt12Invoice_message_paths(this_arg);
46914 return nativeResponseValue;
46916 // MUST_USE_RES struct LDKQuantity Bolt12Invoice_supported_quantity(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46918 export function Bolt12Invoice_supported_quantity(this_arg: bigint): bigint {
46919 if(!isWasmInitialized) {
46920 throw new Error("initializeWasm() must be awaited first!");
46922 const nativeResponseValue = wasm.TS_Bolt12Invoice_supported_quantity(this_arg);
46923 return nativeResponseValue;
46925 // MUST_USE_RES struct LDKu8slice Bolt12Invoice_payer_metadata(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46927 export function Bolt12Invoice_payer_metadata(this_arg: bigint): number {
46928 if(!isWasmInitialized) {
46929 throw new Error("initializeWasm() must be awaited first!");
46931 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_metadata(this_arg);
46932 return nativeResponseValue;
46934 // MUST_USE_RES struct LDKInvoiceRequestFeatures Bolt12Invoice_invoice_request_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46936 export function Bolt12Invoice_invoice_request_features(this_arg: bigint): bigint {
46937 if(!isWasmInitialized) {
46938 throw new Error("initializeWasm() must be awaited first!");
46940 const nativeResponseValue = wasm.TS_Bolt12Invoice_invoice_request_features(this_arg);
46941 return nativeResponseValue;
46943 // MUST_USE_RES struct LDKCOption_u64Z Bolt12Invoice_quantity(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46945 export function Bolt12Invoice_quantity(this_arg: bigint): bigint {
46946 if(!isWasmInitialized) {
46947 throw new Error("initializeWasm() must be awaited first!");
46949 const nativeResponseValue = wasm.TS_Bolt12Invoice_quantity(this_arg);
46950 return nativeResponseValue;
46952 // MUST_USE_RES struct LDKPublicKey Bolt12Invoice_payer_id(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46954 export function Bolt12Invoice_payer_id(this_arg: bigint): number {
46955 if(!isWasmInitialized) {
46956 throw new Error("initializeWasm() must be awaited first!");
46958 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_id(this_arg);
46959 return nativeResponseValue;
46961 // MUST_USE_RES struct LDKPrintableString Bolt12Invoice_payer_note(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46963 export function Bolt12Invoice_payer_note(this_arg: bigint): bigint {
46964 if(!isWasmInitialized) {
46965 throw new Error("initializeWasm() must be awaited first!");
46967 const nativeResponseValue = wasm.TS_Bolt12Invoice_payer_note(this_arg);
46968 return nativeResponseValue;
46970 // MUST_USE_RES uint64_t Bolt12Invoice_created_at(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46972 export function Bolt12Invoice_created_at(this_arg: bigint): bigint {
46973 if(!isWasmInitialized) {
46974 throw new Error("initializeWasm() must be awaited first!");
46976 const nativeResponseValue = wasm.TS_Bolt12Invoice_created_at(this_arg);
46977 return nativeResponseValue;
46979 // MUST_USE_RES uint64_t Bolt12Invoice_relative_expiry(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46981 export function Bolt12Invoice_relative_expiry(this_arg: bigint): bigint {
46982 if(!isWasmInitialized) {
46983 throw new Error("initializeWasm() must be awaited first!");
46985 const nativeResponseValue = wasm.TS_Bolt12Invoice_relative_expiry(this_arg);
46986 return nativeResponseValue;
46988 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_payment_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46990 export function Bolt12Invoice_payment_hash(this_arg: bigint): number {
46991 if(!isWasmInitialized) {
46992 throw new Error("initializeWasm() must be awaited first!");
46994 const nativeResponseValue = wasm.TS_Bolt12Invoice_payment_hash(this_arg);
46995 return nativeResponseValue;
46997 // MUST_USE_RES uint64_t Bolt12Invoice_amount_msats(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
46999 export function Bolt12Invoice_amount_msats(this_arg: bigint): bigint {
47000 if(!isWasmInitialized) {
47001 throw new Error("initializeWasm() must be awaited first!");
47003 const nativeResponseValue = wasm.TS_Bolt12Invoice_amount_msats(this_arg);
47004 return nativeResponseValue;
47006 // MUST_USE_RES struct LDKBolt12InvoiceFeatures Bolt12Invoice_invoice_features(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
47008 export function Bolt12Invoice_invoice_features(this_arg: bigint): bigint {
47009 if(!isWasmInitialized) {
47010 throw new Error("initializeWasm() must be awaited first!");
47012 const nativeResponseValue = wasm.TS_Bolt12Invoice_invoice_features(this_arg);
47013 return nativeResponseValue;
47015 // MUST_USE_RES struct LDKPublicKey Bolt12Invoice_signing_pubkey(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
47017 export function Bolt12Invoice_signing_pubkey(this_arg: bigint): number {
47018 if(!isWasmInitialized) {
47019 throw new Error("initializeWasm() must be awaited first!");
47021 const nativeResponseValue = wasm.TS_Bolt12Invoice_signing_pubkey(this_arg);
47022 return nativeResponseValue;
47024 // MUST_USE_RES struct LDKSchnorrSignature Bolt12Invoice_signature(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
47026 export function Bolt12Invoice_signature(this_arg: bigint): number {
47027 if(!isWasmInitialized) {
47028 throw new Error("initializeWasm() must be awaited first!");
47030 const nativeResponseValue = wasm.TS_Bolt12Invoice_signature(this_arg);
47031 return nativeResponseValue;
47033 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt12Invoice_signable_hash(const struct LDKBolt12Invoice *NONNULL_PTR this_arg);
47035 export function Bolt12Invoice_signable_hash(this_arg: bigint): number {
47036 if(!isWasmInitialized) {
47037 throw new Error("initializeWasm() must be awaited first!");
47039 const nativeResponseValue = wasm.TS_Bolt12Invoice_signable_hash(this_arg);
47040 return nativeResponseValue;
47042 // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesNoneZ Bolt12Invoice_verify(const struct LDKBolt12Invoice *NONNULL_PTR this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
47044 export function Bolt12Invoice_verify(this_arg: bigint, key: bigint): bigint {
47045 if(!isWasmInitialized) {
47046 throw new Error("initializeWasm() must be awaited first!");
47048 const nativeResponseValue = wasm.TS_Bolt12Invoice_verify(this_arg, key);
47049 return nativeResponseValue;
47051 // struct LDKCVec_u8Z UnsignedBolt12Invoice_write(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR obj);
47053 export function UnsignedBolt12Invoice_write(obj: bigint): number {
47054 if(!isWasmInitialized) {
47055 throw new Error("initializeWasm() must be awaited first!");
47057 const nativeResponseValue = wasm.TS_UnsignedBolt12Invoice_write(obj);
47058 return nativeResponseValue;
47060 // struct LDKCVec_u8Z Bolt12Invoice_write(const struct LDKBolt12Invoice *NONNULL_PTR obj);
47062 export function Bolt12Invoice_write(obj: bigint): number {
47063 if(!isWasmInitialized) {
47064 throw new Error("initializeWasm() must be awaited first!");
47066 const nativeResponseValue = wasm.TS_Bolt12Invoice_write(obj);
47067 return nativeResponseValue;
47069 // void BlindedPayInfo_free(struct LDKBlindedPayInfo this_obj);
47071 export function BlindedPayInfo_free(this_obj: bigint): void {
47072 if(!isWasmInitialized) {
47073 throw new Error("initializeWasm() must be awaited first!");
47075 const nativeResponseValue = wasm.TS_BlindedPayInfo_free(this_obj);
47076 // debug statements here
47078 // uint32_t BlindedPayInfo_get_fee_base_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
47080 export function BlindedPayInfo_get_fee_base_msat(this_ptr: bigint): number {
47081 if(!isWasmInitialized) {
47082 throw new Error("initializeWasm() must be awaited first!");
47084 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_base_msat(this_ptr);
47085 return nativeResponseValue;
47087 // void BlindedPayInfo_set_fee_base_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
47089 export function BlindedPayInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
47090 if(!isWasmInitialized) {
47091 throw new Error("initializeWasm() must be awaited first!");
47093 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_base_msat(this_ptr, val);
47094 // debug statements here
47096 // uint32_t BlindedPayInfo_get_fee_proportional_millionths(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
47098 export function BlindedPayInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
47099 if(!isWasmInitialized) {
47100 throw new Error("initializeWasm() must be awaited first!");
47102 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_fee_proportional_millionths(this_ptr);
47103 return nativeResponseValue;
47105 // void BlindedPayInfo_set_fee_proportional_millionths(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint32_t val);
47107 export function BlindedPayInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
47108 if(!isWasmInitialized) {
47109 throw new Error("initializeWasm() must be awaited first!");
47111 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_fee_proportional_millionths(this_ptr, val);
47112 // debug statements here
47114 // uint16_t BlindedPayInfo_get_cltv_expiry_delta(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
47116 export function BlindedPayInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
47117 if(!isWasmInitialized) {
47118 throw new Error("initializeWasm() must be awaited first!");
47120 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_cltv_expiry_delta(this_ptr);
47121 return nativeResponseValue;
47123 // void BlindedPayInfo_set_cltv_expiry_delta(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint16_t val);
47125 export function BlindedPayInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
47126 if(!isWasmInitialized) {
47127 throw new Error("initializeWasm() must be awaited first!");
47129 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_cltv_expiry_delta(this_ptr, val);
47130 // debug statements here
47132 // uint64_t BlindedPayInfo_get_htlc_minimum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
47134 export function BlindedPayInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
47135 if(!isWasmInitialized) {
47136 throw new Error("initializeWasm() must be awaited first!");
47138 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_minimum_msat(this_ptr);
47139 return nativeResponseValue;
47141 // void BlindedPayInfo_set_htlc_minimum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
47143 export function BlindedPayInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
47144 if(!isWasmInitialized) {
47145 throw new Error("initializeWasm() must be awaited first!");
47147 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_minimum_msat(this_ptr, val);
47148 // debug statements here
47150 // uint64_t BlindedPayInfo_get_htlc_maximum_msat(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
47152 export function BlindedPayInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
47153 if(!isWasmInitialized) {
47154 throw new Error("initializeWasm() must be awaited first!");
47156 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_htlc_maximum_msat(this_ptr);
47157 return nativeResponseValue;
47159 // void BlindedPayInfo_set_htlc_maximum_msat(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, uint64_t val);
47161 export function BlindedPayInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
47162 if(!isWasmInitialized) {
47163 throw new Error("initializeWasm() must be awaited first!");
47165 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_htlc_maximum_msat(this_ptr, val);
47166 // debug statements here
47168 // struct LDKBlindedHopFeatures BlindedPayInfo_get_features(const struct LDKBlindedPayInfo *NONNULL_PTR this_ptr);
47170 export function BlindedPayInfo_get_features(this_ptr: bigint): bigint {
47171 if(!isWasmInitialized) {
47172 throw new Error("initializeWasm() must be awaited first!");
47174 const nativeResponseValue = wasm.TS_BlindedPayInfo_get_features(this_ptr);
47175 return nativeResponseValue;
47177 // void BlindedPayInfo_set_features(struct LDKBlindedPayInfo *NONNULL_PTR this_ptr, struct LDKBlindedHopFeatures val);
47179 export function BlindedPayInfo_set_features(this_ptr: bigint, val: bigint): void {
47180 if(!isWasmInitialized) {
47181 throw new Error("initializeWasm() must be awaited first!");
47183 const nativeResponseValue = wasm.TS_BlindedPayInfo_set_features(this_ptr, val);
47184 // debug statements here
47186 // 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);
47188 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 {
47189 if(!isWasmInitialized) {
47190 throw new Error("initializeWasm() must be awaited first!");
47192 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);
47193 return nativeResponseValue;
47195 // uint64_t BlindedPayInfo_clone_ptr(LDKBlindedPayInfo *NONNULL_PTR arg);
47197 export function BlindedPayInfo_clone_ptr(arg: bigint): bigint {
47198 if(!isWasmInitialized) {
47199 throw new Error("initializeWasm() must be awaited first!");
47201 const nativeResponseValue = wasm.TS_BlindedPayInfo_clone_ptr(arg);
47202 return nativeResponseValue;
47204 // struct LDKBlindedPayInfo BlindedPayInfo_clone(const struct LDKBlindedPayInfo *NONNULL_PTR orig);
47206 export function BlindedPayInfo_clone(orig: bigint): bigint {
47207 if(!isWasmInitialized) {
47208 throw new Error("initializeWasm() must be awaited first!");
47210 const nativeResponseValue = wasm.TS_BlindedPayInfo_clone(orig);
47211 return nativeResponseValue;
47213 // uint64_t BlindedPayInfo_hash(const struct LDKBlindedPayInfo *NONNULL_PTR o);
47215 export function BlindedPayInfo_hash(o: bigint): bigint {
47216 if(!isWasmInitialized) {
47217 throw new Error("initializeWasm() must be awaited first!");
47219 const nativeResponseValue = wasm.TS_BlindedPayInfo_hash(o);
47220 return nativeResponseValue;
47222 // bool BlindedPayInfo_eq(const struct LDKBlindedPayInfo *NONNULL_PTR a, const struct LDKBlindedPayInfo *NONNULL_PTR b);
47224 export function BlindedPayInfo_eq(a: bigint, b: bigint): boolean {
47225 if(!isWasmInitialized) {
47226 throw new Error("initializeWasm() must be awaited first!");
47228 const nativeResponseValue = wasm.TS_BlindedPayInfo_eq(a, b);
47229 return nativeResponseValue;
47231 // struct LDKCVec_u8Z BlindedPayInfo_write(const struct LDKBlindedPayInfo *NONNULL_PTR obj);
47233 export function BlindedPayInfo_write(obj: bigint): number {
47234 if(!isWasmInitialized) {
47235 throw new Error("initializeWasm() must be awaited first!");
47237 const nativeResponseValue = wasm.TS_BlindedPayInfo_write(obj);
47238 return nativeResponseValue;
47240 // struct LDKCResult_BlindedPayInfoDecodeErrorZ BlindedPayInfo_read(struct LDKu8slice ser);
47242 export function BlindedPayInfo_read(ser: number): bigint {
47243 if(!isWasmInitialized) {
47244 throw new Error("initializeWasm() must be awaited first!");
47246 const nativeResponseValue = wasm.TS_BlindedPayInfo_read(ser);
47247 return nativeResponseValue;
47249 // void InvoiceError_free(struct LDKInvoiceError this_obj);
47251 export function InvoiceError_free(this_obj: bigint): void {
47252 if(!isWasmInitialized) {
47253 throw new Error("initializeWasm() must be awaited first!");
47255 const nativeResponseValue = wasm.TS_InvoiceError_free(this_obj);
47256 // debug statements here
47258 // struct LDKErroneousField InvoiceError_get_erroneous_field(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
47260 export function InvoiceError_get_erroneous_field(this_ptr: bigint): bigint {
47261 if(!isWasmInitialized) {
47262 throw new Error("initializeWasm() must be awaited first!");
47264 const nativeResponseValue = wasm.TS_InvoiceError_get_erroneous_field(this_ptr);
47265 return nativeResponseValue;
47267 // void InvoiceError_set_erroneous_field(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKErroneousField val);
47269 export function InvoiceError_set_erroneous_field(this_ptr: bigint, val: bigint): void {
47270 if(!isWasmInitialized) {
47271 throw new Error("initializeWasm() must be awaited first!");
47273 const nativeResponseValue = wasm.TS_InvoiceError_set_erroneous_field(this_ptr, val);
47274 // debug statements here
47276 // struct LDKUntrustedString InvoiceError_get_message(const struct LDKInvoiceError *NONNULL_PTR this_ptr);
47278 export function InvoiceError_get_message(this_ptr: bigint): bigint {
47279 if(!isWasmInitialized) {
47280 throw new Error("initializeWasm() must be awaited first!");
47282 const nativeResponseValue = wasm.TS_InvoiceError_get_message(this_ptr);
47283 return nativeResponseValue;
47285 // void InvoiceError_set_message(struct LDKInvoiceError *NONNULL_PTR this_ptr, struct LDKUntrustedString val);
47287 export function InvoiceError_set_message(this_ptr: bigint, val: bigint): void {
47288 if(!isWasmInitialized) {
47289 throw new Error("initializeWasm() must be awaited first!");
47291 const nativeResponseValue = wasm.TS_InvoiceError_set_message(this_ptr, val);
47292 // debug statements here
47294 // MUST_USE_RES struct LDKInvoiceError InvoiceError_new(struct LDKErroneousField erroneous_field_arg, struct LDKUntrustedString message_arg);
47296 export function InvoiceError_new(erroneous_field_arg: bigint, message_arg: bigint): bigint {
47297 if(!isWasmInitialized) {
47298 throw new Error("initializeWasm() must be awaited first!");
47300 const nativeResponseValue = wasm.TS_InvoiceError_new(erroneous_field_arg, message_arg);
47301 return nativeResponseValue;
47303 // uint64_t InvoiceError_clone_ptr(LDKInvoiceError *NONNULL_PTR arg);
47305 export function InvoiceError_clone_ptr(arg: bigint): bigint {
47306 if(!isWasmInitialized) {
47307 throw new Error("initializeWasm() must be awaited first!");
47309 const nativeResponseValue = wasm.TS_InvoiceError_clone_ptr(arg);
47310 return nativeResponseValue;
47312 // struct LDKInvoiceError InvoiceError_clone(const struct LDKInvoiceError *NONNULL_PTR orig);
47314 export function InvoiceError_clone(orig: bigint): bigint {
47315 if(!isWasmInitialized) {
47316 throw new Error("initializeWasm() must be awaited first!");
47318 const nativeResponseValue = wasm.TS_InvoiceError_clone(orig);
47319 return nativeResponseValue;
47321 // void ErroneousField_free(struct LDKErroneousField this_obj);
47323 export function ErroneousField_free(this_obj: bigint): void {
47324 if(!isWasmInitialized) {
47325 throw new Error("initializeWasm() must be awaited first!");
47327 const nativeResponseValue = wasm.TS_ErroneousField_free(this_obj);
47328 // debug statements here
47330 // uint64_t ErroneousField_get_tlv_fieldnum(const struct LDKErroneousField *NONNULL_PTR this_ptr);
47332 export function ErroneousField_get_tlv_fieldnum(this_ptr: bigint): bigint {
47333 if(!isWasmInitialized) {
47334 throw new Error("initializeWasm() must be awaited first!");
47336 const nativeResponseValue = wasm.TS_ErroneousField_get_tlv_fieldnum(this_ptr);
47337 return nativeResponseValue;
47339 // void ErroneousField_set_tlv_fieldnum(struct LDKErroneousField *NONNULL_PTR this_ptr, uint64_t val);
47341 export function ErroneousField_set_tlv_fieldnum(this_ptr: bigint, val: bigint): void {
47342 if(!isWasmInitialized) {
47343 throw new Error("initializeWasm() must be awaited first!");
47345 const nativeResponseValue = wasm.TS_ErroneousField_set_tlv_fieldnum(this_ptr, val);
47346 // debug statements here
47348 // struct LDKCOption_CVec_u8ZZ ErroneousField_get_suggested_value(const struct LDKErroneousField *NONNULL_PTR this_ptr);
47350 export function ErroneousField_get_suggested_value(this_ptr: bigint): bigint {
47351 if(!isWasmInitialized) {
47352 throw new Error("initializeWasm() must be awaited first!");
47354 const nativeResponseValue = wasm.TS_ErroneousField_get_suggested_value(this_ptr);
47355 return nativeResponseValue;
47357 // void ErroneousField_set_suggested_value(struct LDKErroneousField *NONNULL_PTR this_ptr, struct LDKCOption_CVec_u8ZZ val);
47359 export function ErroneousField_set_suggested_value(this_ptr: bigint, val: bigint): void {
47360 if(!isWasmInitialized) {
47361 throw new Error("initializeWasm() must be awaited first!");
47363 const nativeResponseValue = wasm.TS_ErroneousField_set_suggested_value(this_ptr, val);
47364 // debug statements here
47366 // MUST_USE_RES struct LDKErroneousField ErroneousField_new(uint64_t tlv_fieldnum_arg, struct LDKCOption_CVec_u8ZZ suggested_value_arg);
47368 export function ErroneousField_new(tlv_fieldnum_arg: bigint, suggested_value_arg: bigint): bigint {
47369 if(!isWasmInitialized) {
47370 throw new Error("initializeWasm() must be awaited first!");
47372 const nativeResponseValue = wasm.TS_ErroneousField_new(tlv_fieldnum_arg, suggested_value_arg);
47373 return nativeResponseValue;
47375 // uint64_t ErroneousField_clone_ptr(LDKErroneousField *NONNULL_PTR arg);
47377 export function ErroneousField_clone_ptr(arg: bigint): bigint {
47378 if(!isWasmInitialized) {
47379 throw new Error("initializeWasm() must be awaited first!");
47381 const nativeResponseValue = wasm.TS_ErroneousField_clone_ptr(arg);
47382 return nativeResponseValue;
47384 // struct LDKErroneousField ErroneousField_clone(const struct LDKErroneousField *NONNULL_PTR orig);
47386 export function ErroneousField_clone(orig: bigint): bigint {
47387 if(!isWasmInitialized) {
47388 throw new Error("initializeWasm() must be awaited first!");
47390 const nativeResponseValue = wasm.TS_ErroneousField_clone(orig);
47391 return nativeResponseValue;
47393 // MUST_USE_RES struct LDKInvoiceError InvoiceError_from_string(struct LDKStr s);
47395 export function InvoiceError_from_string(s: number): bigint {
47396 if(!isWasmInitialized) {
47397 throw new Error("initializeWasm() must be awaited first!");
47399 const nativeResponseValue = wasm.TS_InvoiceError_from_string(s);
47400 return nativeResponseValue;
47402 // struct LDKCVec_u8Z InvoiceError_write(const struct LDKInvoiceError *NONNULL_PTR obj);
47404 export function InvoiceError_write(obj: bigint): number {
47405 if(!isWasmInitialized) {
47406 throw new Error("initializeWasm() must be awaited first!");
47408 const nativeResponseValue = wasm.TS_InvoiceError_write(obj);
47409 return nativeResponseValue;
47411 // struct LDKCResult_InvoiceErrorDecodeErrorZ InvoiceError_read(struct LDKu8slice ser);
47413 export function InvoiceError_read(ser: number): bigint {
47414 if(!isWasmInitialized) {
47415 throw new Error("initializeWasm() must be awaited first!");
47417 const nativeResponseValue = wasm.TS_InvoiceError_read(ser);
47418 return nativeResponseValue;
47420 // void UnsignedInvoiceRequest_free(struct LDKUnsignedInvoiceRequest this_obj);
47422 export function UnsignedInvoiceRequest_free(this_obj: bigint): void {
47423 if(!isWasmInitialized) {
47424 throw new Error("initializeWasm() must be awaited first!");
47426 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_free(this_obj);
47427 // debug statements here
47429 // MUST_USE_RES struct LDKTaggedHash UnsignedInvoiceRequest_tagged_hash(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47431 export function UnsignedInvoiceRequest_tagged_hash(this_arg: bigint): bigint {
47432 if(!isWasmInitialized) {
47433 throw new Error("initializeWasm() must be awaited first!");
47435 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_tagged_hash(this_arg);
47436 return nativeResponseValue;
47438 // void InvoiceRequest_free(struct LDKInvoiceRequest this_obj);
47440 export function InvoiceRequest_free(this_obj: bigint): void {
47441 if(!isWasmInitialized) {
47442 throw new Error("initializeWasm() must be awaited first!");
47444 const nativeResponseValue = wasm.TS_InvoiceRequest_free(this_obj);
47445 // debug statements here
47447 // uint64_t InvoiceRequest_clone_ptr(LDKInvoiceRequest *NONNULL_PTR arg);
47449 export function InvoiceRequest_clone_ptr(arg: bigint): bigint {
47450 if(!isWasmInitialized) {
47451 throw new Error("initializeWasm() must be awaited first!");
47453 const nativeResponseValue = wasm.TS_InvoiceRequest_clone_ptr(arg);
47454 return nativeResponseValue;
47456 // struct LDKInvoiceRequest InvoiceRequest_clone(const struct LDKInvoiceRequest *NONNULL_PTR orig);
47458 export function InvoiceRequest_clone(orig: bigint): bigint {
47459 if(!isWasmInitialized) {
47460 throw new Error("initializeWasm() must be awaited first!");
47462 const nativeResponseValue = wasm.TS_InvoiceRequest_clone(orig);
47463 return nativeResponseValue;
47465 // void VerifiedInvoiceRequest_free(struct LDKVerifiedInvoiceRequest this_obj);
47467 export function VerifiedInvoiceRequest_free(this_obj: bigint): void {
47468 if(!isWasmInitialized) {
47469 throw new Error("initializeWasm() must be awaited first!");
47471 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_free(this_obj);
47472 // debug statements here
47474 // struct LDKCOption_SecretKeyZ VerifiedInvoiceRequest_get_keys(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr);
47476 export function VerifiedInvoiceRequest_get_keys(this_ptr: bigint): bigint {
47477 if(!isWasmInitialized) {
47478 throw new Error("initializeWasm() must be awaited first!");
47480 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_get_keys(this_ptr);
47481 return nativeResponseValue;
47483 // void VerifiedInvoiceRequest_set_keys(struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_ptr, struct LDKCOption_SecretKeyZ val);
47485 export function VerifiedInvoiceRequest_set_keys(this_ptr: bigint, val: bigint): void {
47486 if(!isWasmInitialized) {
47487 throw new Error("initializeWasm() must be awaited first!");
47489 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_set_keys(this_ptr, val);
47490 // debug statements here
47492 // uint64_t VerifiedInvoiceRequest_clone_ptr(LDKVerifiedInvoiceRequest *NONNULL_PTR arg);
47494 export function VerifiedInvoiceRequest_clone_ptr(arg: bigint): bigint {
47495 if(!isWasmInitialized) {
47496 throw new Error("initializeWasm() must be awaited first!");
47498 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_clone_ptr(arg);
47499 return nativeResponseValue;
47501 // struct LDKVerifiedInvoiceRequest VerifiedInvoiceRequest_clone(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR orig);
47503 export function VerifiedInvoiceRequest_clone(orig: bigint): bigint {
47504 if(!isWasmInitialized) {
47505 throw new Error("initializeWasm() must be awaited first!");
47507 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_clone(orig);
47508 return nativeResponseValue;
47510 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ UnsignedInvoiceRequest_chains(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47512 export function UnsignedInvoiceRequest_chains(this_arg: bigint): number {
47513 if(!isWasmInitialized) {
47514 throw new Error("initializeWasm() must be awaited first!");
47516 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_chains(this_arg);
47517 return nativeResponseValue;
47519 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ UnsignedInvoiceRequest_metadata(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47521 export function UnsignedInvoiceRequest_metadata(this_arg: bigint): bigint {
47522 if(!isWasmInitialized) {
47523 throw new Error("initializeWasm() must be awaited first!");
47525 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_metadata(this_arg);
47526 return nativeResponseValue;
47528 // MUST_USE_RES struct LDKAmount UnsignedInvoiceRequest_amount(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47530 export function UnsignedInvoiceRequest_amount(this_arg: bigint): bigint {
47531 if(!isWasmInitialized) {
47532 throw new Error("initializeWasm() must be awaited first!");
47534 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_amount(this_arg);
47535 return nativeResponseValue;
47537 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_description(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47539 export function UnsignedInvoiceRequest_description(this_arg: bigint): bigint {
47540 if(!isWasmInitialized) {
47541 throw new Error("initializeWasm() must be awaited first!");
47543 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_description(this_arg);
47544 return nativeResponseValue;
47546 // MUST_USE_RES struct LDKOfferFeatures UnsignedInvoiceRequest_offer_features(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47548 export function UnsignedInvoiceRequest_offer_features(this_arg: bigint): bigint {
47549 if(!isWasmInitialized) {
47550 throw new Error("initializeWasm() must be awaited first!");
47552 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_offer_features(this_arg);
47553 return nativeResponseValue;
47555 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_absolute_expiry(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47557 export function UnsignedInvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
47558 if(!isWasmInitialized) {
47559 throw new Error("initializeWasm() must be awaited first!");
47561 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_absolute_expiry(this_arg);
47562 return nativeResponseValue;
47564 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_issuer(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47566 export function UnsignedInvoiceRequest_issuer(this_arg: bigint): bigint {
47567 if(!isWasmInitialized) {
47568 throw new Error("initializeWasm() must be awaited first!");
47570 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_issuer(this_arg);
47571 return nativeResponseValue;
47573 // MUST_USE_RES struct LDKCVec_BlindedPathZ UnsignedInvoiceRequest_paths(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47575 export function UnsignedInvoiceRequest_paths(this_arg: bigint): number {
47576 if(!isWasmInitialized) {
47577 throw new Error("initializeWasm() must be awaited first!");
47579 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_paths(this_arg);
47580 return nativeResponseValue;
47582 // MUST_USE_RES struct LDKQuantity UnsignedInvoiceRequest_supported_quantity(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47584 export function UnsignedInvoiceRequest_supported_quantity(this_arg: bigint): bigint {
47585 if(!isWasmInitialized) {
47586 throw new Error("initializeWasm() must be awaited first!");
47588 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_supported_quantity(this_arg);
47589 return nativeResponseValue;
47591 // MUST_USE_RES struct LDKPublicKey UnsignedInvoiceRequest_signing_pubkey(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47593 export function UnsignedInvoiceRequest_signing_pubkey(this_arg: bigint): number {
47594 if(!isWasmInitialized) {
47595 throw new Error("initializeWasm() must be awaited first!");
47597 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_signing_pubkey(this_arg);
47598 return nativeResponseValue;
47600 // MUST_USE_RES struct LDKu8slice UnsignedInvoiceRequest_payer_metadata(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47602 export function UnsignedInvoiceRequest_payer_metadata(this_arg: bigint): number {
47603 if(!isWasmInitialized) {
47604 throw new Error("initializeWasm() must be awaited first!");
47606 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_metadata(this_arg);
47607 return nativeResponseValue;
47609 // MUST_USE_RES struct LDKThirtyTwoBytes UnsignedInvoiceRequest_chain(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47611 export function UnsignedInvoiceRequest_chain(this_arg: bigint): number {
47612 if(!isWasmInitialized) {
47613 throw new Error("initializeWasm() must be awaited first!");
47615 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_chain(this_arg);
47616 return nativeResponseValue;
47618 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_amount_msats(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47620 export function UnsignedInvoiceRequest_amount_msats(this_arg: bigint): bigint {
47621 if(!isWasmInitialized) {
47622 throw new Error("initializeWasm() must be awaited first!");
47624 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_amount_msats(this_arg);
47625 return nativeResponseValue;
47627 // MUST_USE_RES struct LDKInvoiceRequestFeatures UnsignedInvoiceRequest_invoice_request_features(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47629 export function UnsignedInvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
47630 if(!isWasmInitialized) {
47631 throw new Error("initializeWasm() must be awaited first!");
47633 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_invoice_request_features(this_arg);
47634 return nativeResponseValue;
47636 // MUST_USE_RES struct LDKCOption_u64Z UnsignedInvoiceRequest_quantity(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47638 export function UnsignedInvoiceRequest_quantity(this_arg: bigint): bigint {
47639 if(!isWasmInitialized) {
47640 throw new Error("initializeWasm() must be awaited first!");
47642 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_quantity(this_arg);
47643 return nativeResponseValue;
47645 // MUST_USE_RES struct LDKPublicKey UnsignedInvoiceRequest_payer_id(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47647 export function UnsignedInvoiceRequest_payer_id(this_arg: bigint): number {
47648 if(!isWasmInitialized) {
47649 throw new Error("initializeWasm() must be awaited first!");
47651 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_id(this_arg);
47652 return nativeResponseValue;
47654 // MUST_USE_RES struct LDKPrintableString UnsignedInvoiceRequest_payer_note(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR this_arg);
47656 export function UnsignedInvoiceRequest_payer_note(this_arg: bigint): bigint {
47657 if(!isWasmInitialized) {
47658 throw new Error("initializeWasm() must be awaited first!");
47660 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_payer_note(this_arg);
47661 return nativeResponseValue;
47663 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ InvoiceRequest_chains(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47665 export function InvoiceRequest_chains(this_arg: bigint): number {
47666 if(!isWasmInitialized) {
47667 throw new Error("initializeWasm() must be awaited first!");
47669 const nativeResponseValue = wasm.TS_InvoiceRequest_chains(this_arg);
47670 return nativeResponseValue;
47672 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ InvoiceRequest_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47674 export function InvoiceRequest_metadata(this_arg: bigint): bigint {
47675 if(!isWasmInitialized) {
47676 throw new Error("initializeWasm() must be awaited first!");
47678 const nativeResponseValue = wasm.TS_InvoiceRequest_metadata(this_arg);
47679 return nativeResponseValue;
47681 // MUST_USE_RES struct LDKAmount InvoiceRequest_amount(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47683 export function InvoiceRequest_amount(this_arg: bigint): bigint {
47684 if(!isWasmInitialized) {
47685 throw new Error("initializeWasm() must be awaited first!");
47687 const nativeResponseValue = wasm.TS_InvoiceRequest_amount(this_arg);
47688 return nativeResponseValue;
47690 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_description(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47692 export function InvoiceRequest_description(this_arg: bigint): bigint {
47693 if(!isWasmInitialized) {
47694 throw new Error("initializeWasm() must be awaited first!");
47696 const nativeResponseValue = wasm.TS_InvoiceRequest_description(this_arg);
47697 return nativeResponseValue;
47699 // MUST_USE_RES struct LDKOfferFeatures InvoiceRequest_offer_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47701 export function InvoiceRequest_offer_features(this_arg: bigint): bigint {
47702 if(!isWasmInitialized) {
47703 throw new Error("initializeWasm() must be awaited first!");
47705 const nativeResponseValue = wasm.TS_InvoiceRequest_offer_features(this_arg);
47706 return nativeResponseValue;
47708 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_absolute_expiry(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47710 export function InvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
47711 if(!isWasmInitialized) {
47712 throw new Error("initializeWasm() must be awaited first!");
47714 const nativeResponseValue = wasm.TS_InvoiceRequest_absolute_expiry(this_arg);
47715 return nativeResponseValue;
47717 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_issuer(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47719 export function InvoiceRequest_issuer(this_arg: bigint): bigint {
47720 if(!isWasmInitialized) {
47721 throw new Error("initializeWasm() must be awaited first!");
47723 const nativeResponseValue = wasm.TS_InvoiceRequest_issuer(this_arg);
47724 return nativeResponseValue;
47726 // MUST_USE_RES struct LDKCVec_BlindedPathZ InvoiceRequest_paths(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47728 export function InvoiceRequest_paths(this_arg: bigint): number {
47729 if(!isWasmInitialized) {
47730 throw new Error("initializeWasm() must be awaited first!");
47732 const nativeResponseValue = wasm.TS_InvoiceRequest_paths(this_arg);
47733 return nativeResponseValue;
47735 // MUST_USE_RES struct LDKQuantity InvoiceRequest_supported_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47737 export function InvoiceRequest_supported_quantity(this_arg: bigint): bigint {
47738 if(!isWasmInitialized) {
47739 throw new Error("initializeWasm() must be awaited first!");
47741 const nativeResponseValue = wasm.TS_InvoiceRequest_supported_quantity(this_arg);
47742 return nativeResponseValue;
47744 // MUST_USE_RES struct LDKPublicKey InvoiceRequest_signing_pubkey(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47746 export function InvoiceRequest_signing_pubkey(this_arg: bigint): number {
47747 if(!isWasmInitialized) {
47748 throw new Error("initializeWasm() must be awaited first!");
47750 const nativeResponseValue = wasm.TS_InvoiceRequest_signing_pubkey(this_arg);
47751 return nativeResponseValue;
47753 // MUST_USE_RES struct LDKu8slice InvoiceRequest_payer_metadata(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47755 export function InvoiceRequest_payer_metadata(this_arg: bigint): number {
47756 if(!isWasmInitialized) {
47757 throw new Error("initializeWasm() must be awaited first!");
47759 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_metadata(this_arg);
47760 return nativeResponseValue;
47762 // MUST_USE_RES struct LDKThirtyTwoBytes InvoiceRequest_chain(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47764 export function InvoiceRequest_chain(this_arg: bigint): number {
47765 if(!isWasmInitialized) {
47766 throw new Error("initializeWasm() must be awaited first!");
47768 const nativeResponseValue = wasm.TS_InvoiceRequest_chain(this_arg);
47769 return nativeResponseValue;
47771 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_amount_msats(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47773 export function InvoiceRequest_amount_msats(this_arg: bigint): bigint {
47774 if(!isWasmInitialized) {
47775 throw new Error("initializeWasm() must be awaited first!");
47777 const nativeResponseValue = wasm.TS_InvoiceRequest_amount_msats(this_arg);
47778 return nativeResponseValue;
47780 // MUST_USE_RES struct LDKInvoiceRequestFeatures InvoiceRequest_invoice_request_features(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47782 export function InvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
47783 if(!isWasmInitialized) {
47784 throw new Error("initializeWasm() must be awaited first!");
47786 const nativeResponseValue = wasm.TS_InvoiceRequest_invoice_request_features(this_arg);
47787 return nativeResponseValue;
47789 // MUST_USE_RES struct LDKCOption_u64Z InvoiceRequest_quantity(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47791 export function InvoiceRequest_quantity(this_arg: bigint): bigint {
47792 if(!isWasmInitialized) {
47793 throw new Error("initializeWasm() must be awaited first!");
47795 const nativeResponseValue = wasm.TS_InvoiceRequest_quantity(this_arg);
47796 return nativeResponseValue;
47798 // MUST_USE_RES struct LDKPublicKey InvoiceRequest_payer_id(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47800 export function InvoiceRequest_payer_id(this_arg: bigint): number {
47801 if(!isWasmInitialized) {
47802 throw new Error("initializeWasm() must be awaited first!");
47804 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_id(this_arg);
47805 return nativeResponseValue;
47807 // MUST_USE_RES struct LDKPrintableString InvoiceRequest_payer_note(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47809 export function InvoiceRequest_payer_note(this_arg: bigint): bigint {
47810 if(!isWasmInitialized) {
47811 throw new Error("initializeWasm() must be awaited first!");
47813 const nativeResponseValue = wasm.TS_InvoiceRequest_payer_note(this_arg);
47814 return nativeResponseValue;
47816 // MUST_USE_RES struct LDKSchnorrSignature InvoiceRequest_signature(const struct LDKInvoiceRequest *NONNULL_PTR this_arg);
47818 export function InvoiceRequest_signature(this_arg: bigint): number {
47819 if(!isWasmInitialized) {
47820 throw new Error("initializeWasm() must be awaited first!");
47822 const nativeResponseValue = wasm.TS_InvoiceRequest_signature(this_arg);
47823 return nativeResponseValue;
47825 // MUST_USE_RES struct LDKCResult_VerifiedInvoiceRequestNoneZ InvoiceRequest_verify(struct LDKInvoiceRequest this_arg, const struct LDKExpandedKey *NONNULL_PTR key);
47827 export function InvoiceRequest_verify(this_arg: bigint, key: bigint): bigint {
47828 if(!isWasmInitialized) {
47829 throw new Error("initializeWasm() must be awaited first!");
47831 const nativeResponseValue = wasm.TS_InvoiceRequest_verify(this_arg, key);
47832 return nativeResponseValue;
47834 // MUST_USE_RES struct LDKCVec_ThirtyTwoBytesZ VerifiedInvoiceRequest_chains(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47836 export function VerifiedInvoiceRequest_chains(this_arg: bigint): number {
47837 if(!isWasmInitialized) {
47838 throw new Error("initializeWasm() must be awaited first!");
47840 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_chains(this_arg);
47841 return nativeResponseValue;
47843 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ VerifiedInvoiceRequest_metadata(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47845 export function VerifiedInvoiceRequest_metadata(this_arg: bigint): bigint {
47846 if(!isWasmInitialized) {
47847 throw new Error("initializeWasm() must be awaited first!");
47849 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_metadata(this_arg);
47850 return nativeResponseValue;
47852 // MUST_USE_RES struct LDKAmount VerifiedInvoiceRequest_amount(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47854 export function VerifiedInvoiceRequest_amount(this_arg: bigint): bigint {
47855 if(!isWasmInitialized) {
47856 throw new Error("initializeWasm() must be awaited first!");
47858 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_amount(this_arg);
47859 return nativeResponseValue;
47861 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_description(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47863 export function VerifiedInvoiceRequest_description(this_arg: bigint): bigint {
47864 if(!isWasmInitialized) {
47865 throw new Error("initializeWasm() must be awaited first!");
47867 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_description(this_arg);
47868 return nativeResponseValue;
47870 // MUST_USE_RES struct LDKOfferFeatures VerifiedInvoiceRequest_offer_features(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47872 export function VerifiedInvoiceRequest_offer_features(this_arg: bigint): bigint {
47873 if(!isWasmInitialized) {
47874 throw new Error("initializeWasm() must be awaited first!");
47876 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_offer_features(this_arg);
47877 return nativeResponseValue;
47879 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_absolute_expiry(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47881 export function VerifiedInvoiceRequest_absolute_expiry(this_arg: bigint): bigint {
47882 if(!isWasmInitialized) {
47883 throw new Error("initializeWasm() must be awaited first!");
47885 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_absolute_expiry(this_arg);
47886 return nativeResponseValue;
47888 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_issuer(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47890 export function VerifiedInvoiceRequest_issuer(this_arg: bigint): bigint {
47891 if(!isWasmInitialized) {
47892 throw new Error("initializeWasm() must be awaited first!");
47894 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_issuer(this_arg);
47895 return nativeResponseValue;
47897 // MUST_USE_RES struct LDKCVec_BlindedPathZ VerifiedInvoiceRequest_paths(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47899 export function VerifiedInvoiceRequest_paths(this_arg: bigint): number {
47900 if(!isWasmInitialized) {
47901 throw new Error("initializeWasm() must be awaited first!");
47903 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_paths(this_arg);
47904 return nativeResponseValue;
47906 // MUST_USE_RES struct LDKQuantity VerifiedInvoiceRequest_supported_quantity(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47908 export function VerifiedInvoiceRequest_supported_quantity(this_arg: bigint): bigint {
47909 if(!isWasmInitialized) {
47910 throw new Error("initializeWasm() must be awaited first!");
47912 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_supported_quantity(this_arg);
47913 return nativeResponseValue;
47915 // MUST_USE_RES struct LDKPublicKey VerifiedInvoiceRequest_signing_pubkey(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47917 export function VerifiedInvoiceRequest_signing_pubkey(this_arg: bigint): number {
47918 if(!isWasmInitialized) {
47919 throw new Error("initializeWasm() must be awaited first!");
47921 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_signing_pubkey(this_arg);
47922 return nativeResponseValue;
47924 // MUST_USE_RES struct LDKu8slice VerifiedInvoiceRequest_payer_metadata(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47926 export function VerifiedInvoiceRequest_payer_metadata(this_arg: bigint): number {
47927 if(!isWasmInitialized) {
47928 throw new Error("initializeWasm() must be awaited first!");
47930 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_metadata(this_arg);
47931 return nativeResponseValue;
47933 // MUST_USE_RES struct LDKThirtyTwoBytes VerifiedInvoiceRequest_chain(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47935 export function VerifiedInvoiceRequest_chain(this_arg: bigint): number {
47936 if(!isWasmInitialized) {
47937 throw new Error("initializeWasm() must be awaited first!");
47939 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_chain(this_arg);
47940 return nativeResponseValue;
47942 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_amount_msats(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47944 export function VerifiedInvoiceRequest_amount_msats(this_arg: bigint): bigint {
47945 if(!isWasmInitialized) {
47946 throw new Error("initializeWasm() must be awaited first!");
47948 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_amount_msats(this_arg);
47949 return nativeResponseValue;
47951 // MUST_USE_RES struct LDKInvoiceRequestFeatures VerifiedInvoiceRequest_invoice_request_features(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47953 export function VerifiedInvoiceRequest_invoice_request_features(this_arg: bigint): bigint {
47954 if(!isWasmInitialized) {
47955 throw new Error("initializeWasm() must be awaited first!");
47957 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_invoice_request_features(this_arg);
47958 return nativeResponseValue;
47960 // MUST_USE_RES struct LDKCOption_u64Z VerifiedInvoiceRequest_quantity(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47962 export function VerifiedInvoiceRequest_quantity(this_arg: bigint): bigint {
47963 if(!isWasmInitialized) {
47964 throw new Error("initializeWasm() must be awaited first!");
47966 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_quantity(this_arg);
47967 return nativeResponseValue;
47969 // MUST_USE_RES struct LDKPublicKey VerifiedInvoiceRequest_payer_id(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47971 export function VerifiedInvoiceRequest_payer_id(this_arg: bigint): number {
47972 if(!isWasmInitialized) {
47973 throw new Error("initializeWasm() must be awaited first!");
47975 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_id(this_arg);
47976 return nativeResponseValue;
47978 // MUST_USE_RES struct LDKPrintableString VerifiedInvoiceRequest_payer_note(const struct LDKVerifiedInvoiceRequest *NONNULL_PTR this_arg);
47980 export function VerifiedInvoiceRequest_payer_note(this_arg: bigint): bigint {
47981 if(!isWasmInitialized) {
47982 throw new Error("initializeWasm() must be awaited first!");
47984 const nativeResponseValue = wasm.TS_VerifiedInvoiceRequest_payer_note(this_arg);
47985 return nativeResponseValue;
47987 // struct LDKCVec_u8Z UnsignedInvoiceRequest_write(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR obj);
47989 export function UnsignedInvoiceRequest_write(obj: bigint): number {
47990 if(!isWasmInitialized) {
47991 throw new Error("initializeWasm() must be awaited first!");
47993 const nativeResponseValue = wasm.TS_UnsignedInvoiceRequest_write(obj);
47994 return nativeResponseValue;
47996 // struct LDKCVec_u8Z InvoiceRequest_write(const struct LDKInvoiceRequest *NONNULL_PTR obj);
47998 export function InvoiceRequest_write(obj: bigint): number {
47999 if(!isWasmInitialized) {
48000 throw new Error("initializeWasm() must be awaited first!");
48002 const nativeResponseValue = wasm.TS_InvoiceRequest_write(obj);
48003 return nativeResponseValue;
48005 // void TaggedHash_free(struct LDKTaggedHash this_obj);
48007 export function TaggedHash_free(this_obj: bigint): void {
48008 if(!isWasmInitialized) {
48009 throw new Error("initializeWasm() must be awaited first!");
48011 const nativeResponseValue = wasm.TS_TaggedHash_free(this_obj);
48012 // debug statements here
48014 // uint64_t TaggedHash_clone_ptr(LDKTaggedHash *NONNULL_PTR arg);
48016 export function TaggedHash_clone_ptr(arg: bigint): bigint {
48017 if(!isWasmInitialized) {
48018 throw new Error("initializeWasm() must be awaited first!");
48020 const nativeResponseValue = wasm.TS_TaggedHash_clone_ptr(arg);
48021 return nativeResponseValue;
48023 // struct LDKTaggedHash TaggedHash_clone(const struct LDKTaggedHash *NONNULL_PTR orig);
48025 export function TaggedHash_clone(orig: bigint): bigint {
48026 if(!isWasmInitialized) {
48027 throw new Error("initializeWasm() must be awaited first!");
48029 const nativeResponseValue = wasm.TS_TaggedHash_clone(orig);
48030 return nativeResponseValue;
48032 // MUST_USE_RES const uint8_t (*TaggedHash_as_digest(const struct LDKTaggedHash *NONNULL_PTR this_arg))[32];
48034 export function TaggedHash_as_digest(this_arg: bigint): number {
48035 if(!isWasmInitialized) {
48036 throw new Error("initializeWasm() must be awaited first!");
48038 const nativeResponseValue = wasm.TS_TaggedHash_as_digest(this_arg);
48039 return nativeResponseValue;
48041 // MUST_USE_RES struct LDKStr TaggedHash_tag(const struct LDKTaggedHash *NONNULL_PTR this_arg);
48043 export function TaggedHash_tag(this_arg: bigint): number {
48044 if(!isWasmInitialized) {
48045 throw new Error("initializeWasm() must be awaited first!");
48047 const nativeResponseValue = wasm.TS_TaggedHash_tag(this_arg);
48048 return nativeResponseValue;
48050 // MUST_USE_RES struct LDKThirtyTwoBytes TaggedHash_merkle_root(const struct LDKTaggedHash *NONNULL_PTR this_arg);
48052 export function TaggedHash_merkle_root(this_arg: bigint): number {
48053 if(!isWasmInitialized) {
48054 throw new Error("initializeWasm() must be awaited first!");
48056 const nativeResponseValue = wasm.TS_TaggedHash_merkle_root(this_arg);
48057 return nativeResponseValue;
48059 // void Bolt12ParseError_free(struct LDKBolt12ParseError this_obj);
48061 export function Bolt12ParseError_free(this_obj: bigint): void {
48062 if(!isWasmInitialized) {
48063 throw new Error("initializeWasm() must be awaited first!");
48065 const nativeResponseValue = wasm.TS_Bolt12ParseError_free(this_obj);
48066 // debug statements here
48068 // uint64_t Bolt12ParseError_clone_ptr(LDKBolt12ParseError *NONNULL_PTR arg);
48070 export function Bolt12ParseError_clone_ptr(arg: bigint): bigint {
48071 if(!isWasmInitialized) {
48072 throw new Error("initializeWasm() must be awaited first!");
48074 const nativeResponseValue = wasm.TS_Bolt12ParseError_clone_ptr(arg);
48075 return nativeResponseValue;
48077 // struct LDKBolt12ParseError Bolt12ParseError_clone(const struct LDKBolt12ParseError *NONNULL_PTR orig);
48079 export function Bolt12ParseError_clone(orig: bigint): bigint {
48080 if(!isWasmInitialized) {
48081 throw new Error("initializeWasm() must be awaited first!");
48083 const nativeResponseValue = wasm.TS_Bolt12ParseError_clone(orig);
48084 return nativeResponseValue;
48086 // enum LDKBolt12SemanticError Bolt12SemanticError_clone(const enum LDKBolt12SemanticError *NONNULL_PTR orig);
48088 export function Bolt12SemanticError_clone(orig: bigint): Bolt12SemanticError {
48089 if(!isWasmInitialized) {
48090 throw new Error("initializeWasm() must be awaited first!");
48092 const nativeResponseValue = wasm.TS_Bolt12SemanticError_clone(orig);
48093 return nativeResponseValue;
48095 // enum LDKBolt12SemanticError Bolt12SemanticError_already_expired(void);
48097 export function Bolt12SemanticError_already_expired(): Bolt12SemanticError {
48098 if(!isWasmInitialized) {
48099 throw new Error("initializeWasm() must be awaited first!");
48101 const nativeResponseValue = wasm.TS_Bolt12SemanticError_already_expired();
48102 return nativeResponseValue;
48104 // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_chain(void);
48106 export function Bolt12SemanticError_unsupported_chain(): Bolt12SemanticError {
48107 if(!isWasmInitialized) {
48108 throw new Error("initializeWasm() must be awaited first!");
48110 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_chain();
48111 return nativeResponseValue;
48113 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_chain(void);
48115 export function Bolt12SemanticError_unexpected_chain(): Bolt12SemanticError {
48116 if(!isWasmInitialized) {
48117 throw new Error("initializeWasm() must be awaited first!");
48119 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_chain();
48120 return nativeResponseValue;
48122 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_amount(void);
48124 export function Bolt12SemanticError_missing_amount(): Bolt12SemanticError {
48125 if(!isWasmInitialized) {
48126 throw new Error("initializeWasm() must be awaited first!");
48128 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_amount();
48129 return nativeResponseValue;
48131 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_amount(void);
48133 export function Bolt12SemanticError_invalid_amount(): Bolt12SemanticError {
48134 if(!isWasmInitialized) {
48135 throw new Error("initializeWasm() must be awaited first!");
48137 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_amount();
48138 return nativeResponseValue;
48140 // enum LDKBolt12SemanticError Bolt12SemanticError_insufficient_amount(void);
48142 export function Bolt12SemanticError_insufficient_amount(): Bolt12SemanticError {
48143 if(!isWasmInitialized) {
48144 throw new Error("initializeWasm() must be awaited first!");
48146 const nativeResponseValue = wasm.TS_Bolt12SemanticError_insufficient_amount();
48147 return nativeResponseValue;
48149 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_amount(void);
48151 export function Bolt12SemanticError_unexpected_amount(): Bolt12SemanticError {
48152 if(!isWasmInitialized) {
48153 throw new Error("initializeWasm() must be awaited first!");
48155 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_amount();
48156 return nativeResponseValue;
48158 // enum LDKBolt12SemanticError Bolt12SemanticError_unsupported_currency(void);
48160 export function Bolt12SemanticError_unsupported_currency(): Bolt12SemanticError {
48161 if(!isWasmInitialized) {
48162 throw new Error("initializeWasm() must be awaited first!");
48164 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unsupported_currency();
48165 return nativeResponseValue;
48167 // enum LDKBolt12SemanticError Bolt12SemanticError_unknown_required_features(void);
48169 export function Bolt12SemanticError_unknown_required_features(): Bolt12SemanticError {
48170 if(!isWasmInitialized) {
48171 throw new Error("initializeWasm() must be awaited first!");
48173 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unknown_required_features();
48174 return nativeResponseValue;
48176 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_features(void);
48178 export function Bolt12SemanticError_unexpected_features(): Bolt12SemanticError {
48179 if(!isWasmInitialized) {
48180 throw new Error("initializeWasm() must be awaited first!");
48182 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_features();
48183 return nativeResponseValue;
48185 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_description(void);
48187 export function Bolt12SemanticError_missing_description(): Bolt12SemanticError {
48188 if(!isWasmInitialized) {
48189 throw new Error("initializeWasm() must be awaited first!");
48191 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_description();
48192 return nativeResponseValue;
48194 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signing_pubkey(void);
48196 export function Bolt12SemanticError_missing_signing_pubkey(): Bolt12SemanticError {
48197 if(!isWasmInitialized) {
48198 throw new Error("initializeWasm() must be awaited first!");
48200 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signing_pubkey();
48201 return nativeResponseValue;
48203 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_signing_pubkey(void);
48205 export function Bolt12SemanticError_invalid_signing_pubkey(): Bolt12SemanticError {
48206 if(!isWasmInitialized) {
48207 throw new Error("initializeWasm() must be awaited first!");
48209 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_signing_pubkey();
48210 return nativeResponseValue;
48212 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_signing_pubkey(void);
48214 export function Bolt12SemanticError_unexpected_signing_pubkey(): Bolt12SemanticError {
48215 if(!isWasmInitialized) {
48216 throw new Error("initializeWasm() must be awaited first!");
48218 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_signing_pubkey();
48219 return nativeResponseValue;
48221 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_quantity(void);
48223 export function Bolt12SemanticError_missing_quantity(): Bolt12SemanticError {
48224 if(!isWasmInitialized) {
48225 throw new Error("initializeWasm() must be awaited first!");
48227 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_quantity();
48228 return nativeResponseValue;
48230 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_quantity(void);
48232 export function Bolt12SemanticError_invalid_quantity(): Bolt12SemanticError {
48233 if(!isWasmInitialized) {
48234 throw new Error("initializeWasm() must be awaited first!");
48236 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_quantity();
48237 return nativeResponseValue;
48239 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_quantity(void);
48241 export function Bolt12SemanticError_unexpected_quantity(): Bolt12SemanticError {
48242 if(!isWasmInitialized) {
48243 throw new Error("initializeWasm() must be awaited first!");
48245 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_quantity();
48246 return nativeResponseValue;
48248 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_metadata(void);
48250 export function Bolt12SemanticError_invalid_metadata(): Bolt12SemanticError {
48251 if(!isWasmInitialized) {
48252 throw new Error("initializeWasm() must be awaited first!");
48254 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_metadata();
48255 return nativeResponseValue;
48257 // enum LDKBolt12SemanticError Bolt12SemanticError_unexpected_metadata(void);
48259 export function Bolt12SemanticError_unexpected_metadata(): Bolt12SemanticError {
48260 if(!isWasmInitialized) {
48261 throw new Error("initializeWasm() must be awaited first!");
48263 const nativeResponseValue = wasm.TS_Bolt12SemanticError_unexpected_metadata();
48264 return nativeResponseValue;
48266 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_metadata(void);
48268 export function Bolt12SemanticError_missing_payer_metadata(): Bolt12SemanticError {
48269 if(!isWasmInitialized) {
48270 throw new Error("initializeWasm() must be awaited first!");
48272 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_metadata();
48273 return nativeResponseValue;
48275 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payer_id(void);
48277 export function Bolt12SemanticError_missing_payer_id(): Bolt12SemanticError {
48278 if(!isWasmInitialized) {
48279 throw new Error("initializeWasm() must be awaited first!");
48281 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payer_id();
48282 return nativeResponseValue;
48284 // enum LDKBolt12SemanticError Bolt12SemanticError_duplicate_payment_id(void);
48286 export function Bolt12SemanticError_duplicate_payment_id(): Bolt12SemanticError {
48287 if(!isWasmInitialized) {
48288 throw new Error("initializeWasm() must be awaited first!");
48290 const nativeResponseValue = wasm.TS_Bolt12SemanticError_duplicate_payment_id();
48291 return nativeResponseValue;
48293 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_paths(void);
48295 export function Bolt12SemanticError_missing_paths(): Bolt12SemanticError {
48296 if(!isWasmInitialized) {
48297 throw new Error("initializeWasm() must be awaited first!");
48299 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_paths();
48300 return nativeResponseValue;
48302 // enum LDKBolt12SemanticError Bolt12SemanticError_invalid_pay_info(void);
48304 export function Bolt12SemanticError_invalid_pay_info(): Bolt12SemanticError {
48305 if(!isWasmInitialized) {
48306 throw new Error("initializeWasm() must be awaited first!");
48308 const nativeResponseValue = wasm.TS_Bolt12SemanticError_invalid_pay_info();
48309 return nativeResponseValue;
48311 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_creation_time(void);
48313 export function Bolt12SemanticError_missing_creation_time(): Bolt12SemanticError {
48314 if(!isWasmInitialized) {
48315 throw new Error("initializeWasm() must be awaited first!");
48317 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_creation_time();
48318 return nativeResponseValue;
48320 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_payment_hash(void);
48322 export function Bolt12SemanticError_missing_payment_hash(): Bolt12SemanticError {
48323 if(!isWasmInitialized) {
48324 throw new Error("initializeWasm() must be awaited first!");
48326 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_payment_hash();
48327 return nativeResponseValue;
48329 // enum LDKBolt12SemanticError Bolt12SemanticError_missing_signature(void);
48331 export function Bolt12SemanticError_missing_signature(): Bolt12SemanticError {
48332 if(!isWasmInitialized) {
48333 throw new Error("initializeWasm() must be awaited first!");
48335 const nativeResponseValue = wasm.TS_Bolt12SemanticError_missing_signature();
48336 return nativeResponseValue;
48338 // void Refund_free(struct LDKRefund this_obj);
48340 export function Refund_free(this_obj: bigint): void {
48341 if(!isWasmInitialized) {
48342 throw new Error("initializeWasm() must be awaited first!");
48344 const nativeResponseValue = wasm.TS_Refund_free(this_obj);
48345 // debug statements here
48347 // uint64_t Refund_clone_ptr(LDKRefund *NONNULL_PTR arg);
48349 export function Refund_clone_ptr(arg: bigint): bigint {
48350 if(!isWasmInitialized) {
48351 throw new Error("initializeWasm() must be awaited first!");
48353 const nativeResponseValue = wasm.TS_Refund_clone_ptr(arg);
48354 return nativeResponseValue;
48356 // struct LDKRefund Refund_clone(const struct LDKRefund *NONNULL_PTR orig);
48358 export function Refund_clone(orig: bigint): bigint {
48359 if(!isWasmInitialized) {
48360 throw new Error("initializeWasm() must be awaited first!");
48362 const nativeResponseValue = wasm.TS_Refund_clone(orig);
48363 return nativeResponseValue;
48365 // MUST_USE_RES struct LDKPrintableString Refund_description(const struct LDKRefund *NONNULL_PTR this_arg);
48367 export function Refund_description(this_arg: bigint): bigint {
48368 if(!isWasmInitialized) {
48369 throw new Error("initializeWasm() must be awaited first!");
48371 const nativeResponseValue = wasm.TS_Refund_description(this_arg);
48372 return nativeResponseValue;
48374 // MUST_USE_RES struct LDKCOption_u64Z Refund_absolute_expiry(const struct LDKRefund *NONNULL_PTR this_arg);
48376 export function Refund_absolute_expiry(this_arg: bigint): bigint {
48377 if(!isWasmInitialized) {
48378 throw new Error("initializeWasm() must be awaited first!");
48380 const nativeResponseValue = wasm.TS_Refund_absolute_expiry(this_arg);
48381 return nativeResponseValue;
48383 // MUST_USE_RES bool Refund_is_expired_no_std(const struct LDKRefund *NONNULL_PTR this_arg, uint64_t duration_since_epoch);
48385 export function Refund_is_expired_no_std(this_arg: bigint, duration_since_epoch: bigint): boolean {
48386 if(!isWasmInitialized) {
48387 throw new Error("initializeWasm() must be awaited first!");
48389 const nativeResponseValue = wasm.TS_Refund_is_expired_no_std(this_arg, duration_since_epoch);
48390 return nativeResponseValue;
48392 // MUST_USE_RES struct LDKPrintableString Refund_issuer(const struct LDKRefund *NONNULL_PTR this_arg);
48394 export function Refund_issuer(this_arg: bigint): bigint {
48395 if(!isWasmInitialized) {
48396 throw new Error("initializeWasm() must be awaited first!");
48398 const nativeResponseValue = wasm.TS_Refund_issuer(this_arg);
48399 return nativeResponseValue;
48401 // MUST_USE_RES struct LDKCVec_BlindedPathZ Refund_paths(const struct LDKRefund *NONNULL_PTR this_arg);
48403 export function Refund_paths(this_arg: bigint): number {
48404 if(!isWasmInitialized) {
48405 throw new Error("initializeWasm() must be awaited first!");
48407 const nativeResponseValue = wasm.TS_Refund_paths(this_arg);
48408 return nativeResponseValue;
48410 // MUST_USE_RES struct LDKu8slice Refund_payer_metadata(const struct LDKRefund *NONNULL_PTR this_arg);
48412 export function Refund_payer_metadata(this_arg: bigint): number {
48413 if(!isWasmInitialized) {
48414 throw new Error("initializeWasm() must be awaited first!");
48416 const nativeResponseValue = wasm.TS_Refund_payer_metadata(this_arg);
48417 return nativeResponseValue;
48419 // MUST_USE_RES struct LDKThirtyTwoBytes Refund_chain(const struct LDKRefund *NONNULL_PTR this_arg);
48421 export function Refund_chain(this_arg: bigint): number {
48422 if(!isWasmInitialized) {
48423 throw new Error("initializeWasm() must be awaited first!");
48425 const nativeResponseValue = wasm.TS_Refund_chain(this_arg);
48426 return nativeResponseValue;
48428 // MUST_USE_RES uint64_t Refund_amount_msats(const struct LDKRefund *NONNULL_PTR this_arg);
48430 export function Refund_amount_msats(this_arg: bigint): bigint {
48431 if(!isWasmInitialized) {
48432 throw new Error("initializeWasm() must be awaited first!");
48434 const nativeResponseValue = wasm.TS_Refund_amount_msats(this_arg);
48435 return nativeResponseValue;
48437 // MUST_USE_RES struct LDKInvoiceRequestFeatures Refund_features(const struct LDKRefund *NONNULL_PTR this_arg);
48439 export function Refund_features(this_arg: bigint): bigint {
48440 if(!isWasmInitialized) {
48441 throw new Error("initializeWasm() must be awaited first!");
48443 const nativeResponseValue = wasm.TS_Refund_features(this_arg);
48444 return nativeResponseValue;
48446 // MUST_USE_RES struct LDKCOption_u64Z Refund_quantity(const struct LDKRefund *NONNULL_PTR this_arg);
48448 export function Refund_quantity(this_arg: bigint): bigint {
48449 if(!isWasmInitialized) {
48450 throw new Error("initializeWasm() must be awaited first!");
48452 const nativeResponseValue = wasm.TS_Refund_quantity(this_arg);
48453 return nativeResponseValue;
48455 // MUST_USE_RES struct LDKPublicKey Refund_payer_id(const struct LDKRefund *NONNULL_PTR this_arg);
48457 export function Refund_payer_id(this_arg: bigint): number {
48458 if(!isWasmInitialized) {
48459 throw new Error("initializeWasm() must be awaited first!");
48461 const nativeResponseValue = wasm.TS_Refund_payer_id(this_arg);
48462 return nativeResponseValue;
48464 // MUST_USE_RES struct LDKPrintableString Refund_payer_note(const struct LDKRefund *NONNULL_PTR this_arg);
48466 export function Refund_payer_note(this_arg: bigint): bigint {
48467 if(!isWasmInitialized) {
48468 throw new Error("initializeWasm() must be awaited first!");
48470 const nativeResponseValue = wasm.TS_Refund_payer_note(this_arg);
48471 return nativeResponseValue;
48473 // struct LDKCVec_u8Z Refund_write(const struct LDKRefund *NONNULL_PTR obj);
48475 export function Refund_write(obj: bigint): number {
48476 if(!isWasmInitialized) {
48477 throw new Error("initializeWasm() must be awaited first!");
48479 const nativeResponseValue = wasm.TS_Refund_write(obj);
48480 return nativeResponseValue;
48482 // struct LDKCResult_RefundBolt12ParseErrorZ Refund_from_str(struct LDKStr s);
48484 export function Refund_from_str(s: number): bigint {
48485 if(!isWasmInitialized) {
48486 throw new Error("initializeWasm() must be awaited first!");
48488 const nativeResponseValue = wasm.TS_Refund_from_str(s);
48489 return nativeResponseValue;
48491 // enum LDKUtxoLookupError UtxoLookupError_clone(const enum LDKUtxoLookupError *NONNULL_PTR orig);
48493 export function UtxoLookupError_clone(orig: bigint): UtxoLookupError {
48494 if(!isWasmInitialized) {
48495 throw new Error("initializeWasm() must be awaited first!");
48497 const nativeResponseValue = wasm.TS_UtxoLookupError_clone(orig);
48498 return nativeResponseValue;
48500 // enum LDKUtxoLookupError UtxoLookupError_unknown_chain(void);
48502 export function UtxoLookupError_unknown_chain(): UtxoLookupError {
48503 if(!isWasmInitialized) {
48504 throw new Error("initializeWasm() must be awaited first!");
48506 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_chain();
48507 return nativeResponseValue;
48509 // enum LDKUtxoLookupError UtxoLookupError_unknown_tx(void);
48511 export function UtxoLookupError_unknown_tx(): UtxoLookupError {
48512 if(!isWasmInitialized) {
48513 throw new Error("initializeWasm() must be awaited first!");
48515 const nativeResponseValue = wasm.TS_UtxoLookupError_unknown_tx();
48516 return nativeResponseValue;
48518 // void UtxoResult_free(struct LDKUtxoResult this_ptr);
48520 export function UtxoResult_free(this_ptr: bigint): void {
48521 if(!isWasmInitialized) {
48522 throw new Error("initializeWasm() must be awaited first!");
48524 const nativeResponseValue = wasm.TS_UtxoResult_free(this_ptr);
48525 // debug statements here
48527 // uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg);
48529 export function UtxoResult_clone_ptr(arg: bigint): bigint {
48530 if(!isWasmInitialized) {
48531 throw new Error("initializeWasm() must be awaited first!");
48533 const nativeResponseValue = wasm.TS_UtxoResult_clone_ptr(arg);
48534 return nativeResponseValue;
48536 // struct LDKUtxoResult UtxoResult_clone(const struct LDKUtxoResult *NONNULL_PTR orig);
48538 export function UtxoResult_clone(orig: bigint): bigint {
48539 if(!isWasmInitialized) {
48540 throw new Error("initializeWasm() must be awaited first!");
48542 const nativeResponseValue = wasm.TS_UtxoResult_clone(orig);
48543 return nativeResponseValue;
48545 // struct LDKUtxoResult UtxoResult_sync(struct LDKCResult_TxOutUtxoLookupErrorZ a);
48547 export function UtxoResult_sync(a: bigint): bigint {
48548 if(!isWasmInitialized) {
48549 throw new Error("initializeWasm() must be awaited first!");
48551 const nativeResponseValue = wasm.TS_UtxoResult_sync(a);
48552 return nativeResponseValue;
48554 // struct LDKUtxoResult UtxoResult_async(struct LDKUtxoFuture a);
48556 export function UtxoResult_async(a: bigint): bigint {
48557 if(!isWasmInitialized) {
48558 throw new Error("initializeWasm() must be awaited first!");
48560 const nativeResponseValue = wasm.TS_UtxoResult_async(a);
48561 return nativeResponseValue;
48563 // void UtxoLookup_free(struct LDKUtxoLookup this_ptr);
48565 export function UtxoLookup_free(this_ptr: bigint): void {
48566 if(!isWasmInitialized) {
48567 throw new Error("initializeWasm() must be awaited first!");
48569 const nativeResponseValue = wasm.TS_UtxoLookup_free(this_ptr);
48570 // debug statements here
48572 // void UtxoFuture_free(struct LDKUtxoFuture this_obj);
48574 export function UtxoFuture_free(this_obj: bigint): void {
48575 if(!isWasmInitialized) {
48576 throw new Error("initializeWasm() must be awaited first!");
48578 const nativeResponseValue = wasm.TS_UtxoFuture_free(this_obj);
48579 // debug statements here
48581 // uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg);
48583 export function UtxoFuture_clone_ptr(arg: bigint): bigint {
48584 if(!isWasmInitialized) {
48585 throw new Error("initializeWasm() must be awaited first!");
48587 const nativeResponseValue = wasm.TS_UtxoFuture_clone_ptr(arg);
48588 return nativeResponseValue;
48590 // struct LDKUtxoFuture UtxoFuture_clone(const struct LDKUtxoFuture *NONNULL_PTR orig);
48592 export function UtxoFuture_clone(orig: bigint): bigint {
48593 if(!isWasmInitialized) {
48594 throw new Error("initializeWasm() must be awaited first!");
48596 const nativeResponseValue = wasm.TS_UtxoFuture_clone(orig);
48597 return nativeResponseValue;
48599 // MUST_USE_RES struct LDKUtxoFuture UtxoFuture_new(void);
48601 export function UtxoFuture_new(): bigint {
48602 if(!isWasmInitialized) {
48603 throw new Error("initializeWasm() must be awaited first!");
48605 const nativeResponseValue = wasm.TS_UtxoFuture_new();
48606 return nativeResponseValue;
48608 // void UtxoFuture_resolve_without_forwarding(const struct LDKUtxoFuture *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR graph, struct LDKCResult_TxOutUtxoLookupErrorZ result);
48610 export function UtxoFuture_resolve_without_forwarding(this_arg: bigint, graph: bigint, result: bigint): void {
48611 if(!isWasmInitialized) {
48612 throw new Error("initializeWasm() must be awaited first!");
48614 const nativeResponseValue = wasm.TS_UtxoFuture_resolve_without_forwarding(this_arg, graph, result);
48615 // debug statements here
48617 // 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);
48619 export function UtxoFuture_resolve(this_arg: bigint, graph: bigint, gossip: bigint, result: bigint): void {
48620 if(!isWasmInitialized) {
48621 throw new Error("initializeWasm() must be awaited first!");
48623 const nativeResponseValue = wasm.TS_UtxoFuture_resolve(this_arg, graph, gossip, result);
48624 // debug statements here
48626 // void NodeId_free(struct LDKNodeId this_obj);
48628 export function NodeId_free(this_obj: bigint): void {
48629 if(!isWasmInitialized) {
48630 throw new Error("initializeWasm() must be awaited first!");
48632 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
48633 // debug statements here
48635 // uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
48637 export function NodeId_clone_ptr(arg: bigint): bigint {
48638 if(!isWasmInitialized) {
48639 throw new Error("initializeWasm() must be awaited first!");
48641 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
48642 return nativeResponseValue;
48644 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
48646 export function NodeId_clone(orig: bigint): bigint {
48647 if(!isWasmInitialized) {
48648 throw new Error("initializeWasm() must be awaited first!");
48650 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
48651 return nativeResponseValue;
48653 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
48655 export function NodeId_from_pubkey(pubkey: number): bigint {
48656 if(!isWasmInitialized) {
48657 throw new Error("initializeWasm() must be awaited first!");
48659 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
48660 return nativeResponseValue;
48662 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
48664 export function NodeId_as_slice(this_arg: bigint): number {
48665 if(!isWasmInitialized) {
48666 throw new Error("initializeWasm() must be awaited first!");
48668 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
48669 return nativeResponseValue;
48671 // MUST_USE_RES const uint8_t (*NodeId_as_array(const struct LDKNodeId *NONNULL_PTR this_arg))[33];
48673 export function NodeId_as_array(this_arg: bigint): number {
48674 if(!isWasmInitialized) {
48675 throw new Error("initializeWasm() must be awaited first!");
48677 const nativeResponseValue = wasm.TS_NodeId_as_array(this_arg);
48678 return nativeResponseValue;
48680 // MUST_USE_RES struct LDKCResult_PublicKeySecp256k1ErrorZ NodeId_as_pubkey(const struct LDKNodeId *NONNULL_PTR this_arg);
48682 export function NodeId_as_pubkey(this_arg: bigint): bigint {
48683 if(!isWasmInitialized) {
48684 throw new Error("initializeWasm() must be awaited first!");
48686 const nativeResponseValue = wasm.TS_NodeId_as_pubkey(this_arg);
48687 return nativeResponseValue;
48689 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
48691 export function NodeId_hash(o: bigint): bigint {
48692 if(!isWasmInitialized) {
48693 throw new Error("initializeWasm() must be awaited first!");
48695 const nativeResponseValue = wasm.TS_NodeId_hash(o);
48696 return nativeResponseValue;
48698 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
48700 export function NodeId_write(obj: bigint): number {
48701 if(!isWasmInitialized) {
48702 throw new Error("initializeWasm() must be awaited first!");
48704 const nativeResponseValue = wasm.TS_NodeId_write(obj);
48705 return nativeResponseValue;
48707 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
48709 export function NodeId_read(ser: number): bigint {
48710 if(!isWasmInitialized) {
48711 throw new Error("initializeWasm() must be awaited first!");
48713 const nativeResponseValue = wasm.TS_NodeId_read(ser);
48714 return nativeResponseValue;
48716 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
48718 export function NetworkGraph_free(this_obj: bigint): void {
48719 if(!isWasmInitialized) {
48720 throw new Error("initializeWasm() must be awaited first!");
48722 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
48723 // debug statements here
48725 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
48727 export function ReadOnlyNetworkGraph_free(this_obj: bigint): void {
48728 if(!isWasmInitialized) {
48729 throw new Error("initializeWasm() must be awaited first!");
48731 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
48732 // debug statements here
48734 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
48736 export function NetworkUpdate_free(this_ptr: bigint): void {
48737 if(!isWasmInitialized) {
48738 throw new Error("initializeWasm() must be awaited first!");
48740 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
48741 // debug statements here
48743 // uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
48745 export function NetworkUpdate_clone_ptr(arg: bigint): bigint {
48746 if(!isWasmInitialized) {
48747 throw new Error("initializeWasm() must be awaited first!");
48749 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
48750 return nativeResponseValue;
48752 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
48754 export function NetworkUpdate_clone(orig: bigint): bigint {
48755 if(!isWasmInitialized) {
48756 throw new Error("initializeWasm() must be awaited first!");
48758 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
48759 return nativeResponseValue;
48761 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
48763 export function NetworkUpdate_channel_update_message(msg: bigint): bigint {
48764 if(!isWasmInitialized) {
48765 throw new Error("initializeWasm() must be awaited first!");
48767 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
48768 return nativeResponseValue;
48770 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
48772 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): bigint {
48773 if(!isWasmInitialized) {
48774 throw new Error("initializeWasm() must be awaited first!");
48776 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
48777 return nativeResponseValue;
48779 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
48781 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): bigint {
48782 if(!isWasmInitialized) {
48783 throw new Error("initializeWasm() must be awaited first!");
48785 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
48786 return nativeResponseValue;
48788 // bool NetworkUpdate_eq(const struct LDKNetworkUpdate *NONNULL_PTR a, const struct LDKNetworkUpdate *NONNULL_PTR b);
48790 export function NetworkUpdate_eq(a: bigint, b: bigint): boolean {
48791 if(!isWasmInitialized) {
48792 throw new Error("initializeWasm() must be awaited first!");
48794 const nativeResponseValue = wasm.TS_NetworkUpdate_eq(a, b);
48795 return nativeResponseValue;
48797 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
48799 export function NetworkUpdate_write(obj: bigint): number {
48800 if(!isWasmInitialized) {
48801 throw new Error("initializeWasm() must be awaited first!");
48803 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
48804 return nativeResponseValue;
48806 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
48808 export function NetworkUpdate_read(ser: number): bigint {
48809 if(!isWasmInitialized) {
48810 throw new Error("initializeWasm() must be awaited first!");
48812 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
48813 return nativeResponseValue;
48815 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
48817 export function P2PGossipSync_free(this_obj: bigint): void {
48818 if(!isWasmInitialized) {
48819 throw new Error("initializeWasm() must be awaited first!");
48821 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
48822 // debug statements here
48824 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_UtxoLookupZ utxo_lookup, struct LDKLogger logger);
48826 export function P2PGossipSync_new(network_graph: bigint, utxo_lookup: bigint, logger: bigint): bigint {
48827 if(!isWasmInitialized) {
48828 throw new Error("initializeWasm() must be awaited first!");
48830 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, utxo_lookup, logger);
48831 return nativeResponseValue;
48833 // void P2PGossipSync_add_utxo_lookup(const struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_UtxoLookupZ utxo_lookup);
48835 export function P2PGossipSync_add_utxo_lookup(this_arg: bigint, utxo_lookup: bigint): void {
48836 if(!isWasmInitialized) {
48837 throw new Error("initializeWasm() must be awaited first!");
48839 const nativeResponseValue = wasm.TS_P2PGossipSync_add_utxo_lookup(this_arg, utxo_lookup);
48840 // debug statements here
48842 // void NetworkGraph_handle_network_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNetworkUpdate *NONNULL_PTR network_update);
48844 export function NetworkGraph_handle_network_update(this_arg: bigint, network_update: bigint): void {
48845 if(!isWasmInitialized) {
48846 throw new Error("initializeWasm() must be awaited first!");
48848 const nativeResponseValue = wasm.TS_NetworkGraph_handle_network_update(this_arg, network_update);
48849 // debug statements here
48851 // MUST_USE_RES struct LDKThirtyTwoBytes NetworkGraph_get_chain_hash(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
48853 export function NetworkGraph_get_chain_hash(this_arg: bigint): number {
48854 if(!isWasmInitialized) {
48855 throw new Error("initializeWasm() must be awaited first!");
48857 const nativeResponseValue = wasm.TS_NetworkGraph_get_chain_hash(this_arg);
48858 return nativeResponseValue;
48860 // struct LDKCResult_NoneLightningErrorZ verify_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
48862 export function verify_node_announcement(msg: bigint): bigint {
48863 if(!isWasmInitialized) {
48864 throw new Error("initializeWasm() must be awaited first!");
48866 const nativeResponseValue = wasm.TS_verify_node_announcement(msg);
48867 return nativeResponseValue;
48869 // struct LDKCResult_NoneLightningErrorZ verify_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
48871 export function verify_channel_announcement(msg: bigint): bigint {
48872 if(!isWasmInitialized) {
48873 throw new Error("initializeWasm() must be awaited first!");
48875 const nativeResponseValue = wasm.TS_verify_channel_announcement(msg);
48876 return nativeResponseValue;
48878 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
48880 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: bigint): bigint {
48881 if(!isWasmInitialized) {
48882 throw new Error("initializeWasm() must be awaited first!");
48884 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
48885 return nativeResponseValue;
48887 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
48889 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: bigint): bigint {
48890 if(!isWasmInitialized) {
48891 throw new Error("initializeWasm() must be awaited first!");
48893 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
48894 return nativeResponseValue;
48896 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
48898 export function ChannelUpdateInfo_free(this_obj: bigint): void {
48899 if(!isWasmInitialized) {
48900 throw new Error("initializeWasm() must be awaited first!");
48902 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
48903 // debug statements here
48905 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
48907 export function ChannelUpdateInfo_get_last_update(this_ptr: bigint): number {
48908 if(!isWasmInitialized) {
48909 throw new Error("initializeWasm() must be awaited first!");
48911 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
48912 return nativeResponseValue;
48914 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
48916 export function ChannelUpdateInfo_set_last_update(this_ptr: bigint, val: number): void {
48917 if(!isWasmInitialized) {
48918 throw new Error("initializeWasm() must be awaited first!");
48920 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
48921 // debug statements here
48923 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
48925 export function ChannelUpdateInfo_get_enabled(this_ptr: bigint): boolean {
48926 if(!isWasmInitialized) {
48927 throw new Error("initializeWasm() must be awaited first!");
48929 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
48930 return nativeResponseValue;
48932 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
48934 export function ChannelUpdateInfo_set_enabled(this_ptr: bigint, val: boolean): void {
48935 if(!isWasmInitialized) {
48936 throw new Error("initializeWasm() must be awaited first!");
48938 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
48939 // debug statements here
48941 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
48943 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
48944 if(!isWasmInitialized) {
48945 throw new Error("initializeWasm() must be awaited first!");
48947 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
48948 return nativeResponseValue;
48950 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
48952 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
48953 if(!isWasmInitialized) {
48954 throw new Error("initializeWasm() must be awaited first!");
48956 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
48957 // debug statements here
48959 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
48961 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: bigint): bigint {
48962 if(!isWasmInitialized) {
48963 throw new Error("initializeWasm() must be awaited first!");
48965 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
48966 return nativeResponseValue;
48968 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
48970 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
48971 if(!isWasmInitialized) {
48972 throw new Error("initializeWasm() must be awaited first!");
48974 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
48975 // debug statements here
48977 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
48979 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: bigint): bigint {
48980 if(!isWasmInitialized) {
48981 throw new Error("initializeWasm() must be awaited first!");
48983 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
48984 return nativeResponseValue;
48986 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
48988 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
48989 if(!isWasmInitialized) {
48990 throw new Error("initializeWasm() must be awaited first!");
48992 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
48993 // debug statements here
48995 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
48997 export function ChannelUpdateInfo_get_fees(this_ptr: bigint): bigint {
48998 if(!isWasmInitialized) {
48999 throw new Error("initializeWasm() must be awaited first!");
49001 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
49002 return nativeResponseValue;
49004 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
49006 export function ChannelUpdateInfo_set_fees(this_ptr: bigint, val: bigint): void {
49007 if(!isWasmInitialized) {
49008 throw new Error("initializeWasm() must be awaited first!");
49010 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
49011 // debug statements here
49013 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
49015 export function ChannelUpdateInfo_get_last_update_message(this_ptr: bigint): bigint {
49016 if(!isWasmInitialized) {
49017 throw new Error("initializeWasm() must be awaited first!");
49019 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
49020 return nativeResponseValue;
49022 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
49024 export function ChannelUpdateInfo_set_last_update_message(this_ptr: bigint, val: bigint): void {
49025 if(!isWasmInitialized) {
49026 throw new Error("initializeWasm() must be awaited first!");
49028 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
49029 // debug statements here
49031 // 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);
49033 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 {
49034 if(!isWasmInitialized) {
49035 throw new Error("initializeWasm() must be awaited first!");
49037 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);
49038 return nativeResponseValue;
49040 // uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
49042 export function ChannelUpdateInfo_clone_ptr(arg: bigint): bigint {
49043 if(!isWasmInitialized) {
49044 throw new Error("initializeWasm() must be awaited first!");
49046 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
49047 return nativeResponseValue;
49049 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
49051 export function ChannelUpdateInfo_clone(orig: bigint): bigint {
49052 if(!isWasmInitialized) {
49053 throw new Error("initializeWasm() must be awaited first!");
49055 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
49056 return nativeResponseValue;
49058 // bool ChannelUpdateInfo_eq(const struct LDKChannelUpdateInfo *NONNULL_PTR a, const struct LDKChannelUpdateInfo *NONNULL_PTR b);
49060 export function ChannelUpdateInfo_eq(a: bigint, b: bigint): boolean {
49061 if(!isWasmInitialized) {
49062 throw new Error("initializeWasm() must be awaited first!");
49064 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
49065 return nativeResponseValue;
49067 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
49069 export function ChannelUpdateInfo_write(obj: bigint): number {
49070 if(!isWasmInitialized) {
49071 throw new Error("initializeWasm() must be awaited first!");
49073 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
49074 return nativeResponseValue;
49076 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
49078 export function ChannelUpdateInfo_read(ser: number): bigint {
49079 if(!isWasmInitialized) {
49080 throw new Error("initializeWasm() must be awaited first!");
49082 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
49083 return nativeResponseValue;
49085 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
49087 export function ChannelInfo_free(this_obj: bigint): void {
49088 if(!isWasmInitialized) {
49089 throw new Error("initializeWasm() must be awaited first!");
49091 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
49092 // debug statements here
49094 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
49096 export function ChannelInfo_get_features(this_ptr: bigint): bigint {
49097 if(!isWasmInitialized) {
49098 throw new Error("initializeWasm() must be awaited first!");
49100 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
49101 return nativeResponseValue;
49103 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
49105 export function ChannelInfo_set_features(this_ptr: bigint, val: bigint): void {
49106 if(!isWasmInitialized) {
49107 throw new Error("initializeWasm() must be awaited first!");
49109 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
49110 // debug statements here
49112 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
49114 export function ChannelInfo_get_node_one(this_ptr: bigint): bigint {
49115 if(!isWasmInitialized) {
49116 throw new Error("initializeWasm() must be awaited first!");
49118 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
49119 return nativeResponseValue;
49121 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
49123 export function ChannelInfo_set_node_one(this_ptr: bigint, val: bigint): void {
49124 if(!isWasmInitialized) {
49125 throw new Error("initializeWasm() must be awaited first!");
49127 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
49128 // debug statements here
49130 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
49132 export function ChannelInfo_get_one_to_two(this_ptr: bigint): bigint {
49133 if(!isWasmInitialized) {
49134 throw new Error("initializeWasm() must be awaited first!");
49136 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
49137 return nativeResponseValue;
49139 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
49141 export function ChannelInfo_set_one_to_two(this_ptr: bigint, val: bigint): void {
49142 if(!isWasmInitialized) {
49143 throw new Error("initializeWasm() must be awaited first!");
49145 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
49146 // debug statements here
49148 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
49150 export function ChannelInfo_get_node_two(this_ptr: bigint): bigint {
49151 if(!isWasmInitialized) {
49152 throw new Error("initializeWasm() must be awaited first!");
49154 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
49155 return nativeResponseValue;
49157 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
49159 export function ChannelInfo_set_node_two(this_ptr: bigint, val: bigint): void {
49160 if(!isWasmInitialized) {
49161 throw new Error("initializeWasm() must be awaited first!");
49163 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
49164 // debug statements here
49166 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
49168 export function ChannelInfo_get_two_to_one(this_ptr: bigint): bigint {
49169 if(!isWasmInitialized) {
49170 throw new Error("initializeWasm() must be awaited first!");
49172 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
49173 return nativeResponseValue;
49175 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
49177 export function ChannelInfo_set_two_to_one(this_ptr: bigint, val: bigint): void {
49178 if(!isWasmInitialized) {
49179 throw new Error("initializeWasm() must be awaited first!");
49181 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
49182 // debug statements here
49184 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
49186 export function ChannelInfo_get_capacity_sats(this_ptr: bigint): bigint {
49187 if(!isWasmInitialized) {
49188 throw new Error("initializeWasm() must be awaited first!");
49190 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
49191 return nativeResponseValue;
49193 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
49195 export function ChannelInfo_set_capacity_sats(this_ptr: bigint, val: bigint): void {
49196 if(!isWasmInitialized) {
49197 throw new Error("initializeWasm() must be awaited first!");
49199 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
49200 // debug statements here
49202 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
49204 export function ChannelInfo_get_announcement_message(this_ptr: bigint): bigint {
49205 if(!isWasmInitialized) {
49206 throw new Error("initializeWasm() must be awaited first!");
49208 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
49209 return nativeResponseValue;
49211 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
49213 export function ChannelInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
49214 if(!isWasmInitialized) {
49215 throw new Error("initializeWasm() must be awaited first!");
49217 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
49218 // debug statements here
49220 // uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
49222 export function ChannelInfo_clone_ptr(arg: bigint): bigint {
49223 if(!isWasmInitialized) {
49224 throw new Error("initializeWasm() must be awaited first!");
49226 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
49227 return nativeResponseValue;
49229 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
49231 export function ChannelInfo_clone(orig: bigint): bigint {
49232 if(!isWasmInitialized) {
49233 throw new Error("initializeWasm() must be awaited first!");
49235 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
49236 return nativeResponseValue;
49238 // bool ChannelInfo_eq(const struct LDKChannelInfo *NONNULL_PTR a, const struct LDKChannelInfo *NONNULL_PTR b);
49240 export function ChannelInfo_eq(a: bigint, b: bigint): boolean {
49241 if(!isWasmInitialized) {
49242 throw new Error("initializeWasm() must be awaited first!");
49244 const nativeResponseValue = wasm.TS_ChannelInfo_eq(a, b);
49245 return nativeResponseValue;
49247 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
49249 export function ChannelInfo_get_directional_info(this_arg: bigint, channel_flags: number): bigint {
49250 if(!isWasmInitialized) {
49251 throw new Error("initializeWasm() must be awaited first!");
49253 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
49254 return nativeResponseValue;
49256 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
49258 export function ChannelInfo_write(obj: bigint): number {
49259 if(!isWasmInitialized) {
49260 throw new Error("initializeWasm() must be awaited first!");
49262 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
49263 return nativeResponseValue;
49265 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
49267 export function ChannelInfo_read(ser: number): bigint {
49268 if(!isWasmInitialized) {
49269 throw new Error("initializeWasm() must be awaited first!");
49271 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
49272 return nativeResponseValue;
49274 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
49276 export function DirectedChannelInfo_free(this_obj: bigint): void {
49277 if(!isWasmInitialized) {
49278 throw new Error("initializeWasm() must be awaited first!");
49280 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
49281 // debug statements here
49283 // uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
49285 export function DirectedChannelInfo_clone_ptr(arg: bigint): bigint {
49286 if(!isWasmInitialized) {
49287 throw new Error("initializeWasm() must be awaited first!");
49289 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
49290 return nativeResponseValue;
49292 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
49294 export function DirectedChannelInfo_clone(orig: bigint): bigint {
49295 if(!isWasmInitialized) {
49296 throw new Error("initializeWasm() must be awaited first!");
49298 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
49299 return nativeResponseValue;
49301 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
49303 export function DirectedChannelInfo_channel(this_arg: bigint): bigint {
49304 if(!isWasmInitialized) {
49305 throw new Error("initializeWasm() must be awaited first!");
49307 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
49308 return nativeResponseValue;
49310 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
49312 export function DirectedChannelInfo_effective_capacity(this_arg: bigint): bigint {
49313 if(!isWasmInitialized) {
49314 throw new Error("initializeWasm() must be awaited first!");
49316 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
49317 return nativeResponseValue;
49319 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
49321 export function EffectiveCapacity_free(this_ptr: bigint): void {
49322 if(!isWasmInitialized) {
49323 throw new Error("initializeWasm() must be awaited first!");
49325 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
49326 // debug statements here
49328 // uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
49330 export function EffectiveCapacity_clone_ptr(arg: bigint): bigint {
49331 if(!isWasmInitialized) {
49332 throw new Error("initializeWasm() must be awaited first!");
49334 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
49335 return nativeResponseValue;
49337 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
49339 export function EffectiveCapacity_clone(orig: bigint): bigint {
49340 if(!isWasmInitialized) {
49341 throw new Error("initializeWasm() must be awaited first!");
49343 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
49344 return nativeResponseValue;
49346 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
49348 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): bigint {
49349 if(!isWasmInitialized) {
49350 throw new Error("initializeWasm() must be awaited first!");
49352 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
49353 return nativeResponseValue;
49355 // struct LDKEffectiveCapacity EffectiveCapacity_advertised_max_htlc(uint64_t amount_msat);
49357 export function EffectiveCapacity_advertised_max_htlc(amount_msat: bigint): bigint {
49358 if(!isWasmInitialized) {
49359 throw new Error("initializeWasm() must be awaited first!");
49361 const nativeResponseValue = wasm.TS_EffectiveCapacity_advertised_max_htlc(amount_msat);
49362 return nativeResponseValue;
49364 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, uint64_t htlc_maximum_msat);
49366 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: bigint): bigint {
49367 if(!isWasmInitialized) {
49368 throw new Error("initializeWasm() must be awaited first!");
49370 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
49371 return nativeResponseValue;
49373 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
49375 export function EffectiveCapacity_infinite(): bigint {
49376 if(!isWasmInitialized) {
49377 throw new Error("initializeWasm() must be awaited first!");
49379 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
49380 return nativeResponseValue;
49382 // struct LDKEffectiveCapacity EffectiveCapacity_hint_max_htlc(uint64_t amount_msat);
49384 export function EffectiveCapacity_hint_max_htlc(amount_msat: bigint): bigint {
49385 if(!isWasmInitialized) {
49386 throw new Error("initializeWasm() must be awaited first!");
49388 const nativeResponseValue = wasm.TS_EffectiveCapacity_hint_max_htlc(amount_msat);
49389 return nativeResponseValue;
49391 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
49393 export function EffectiveCapacity_unknown(): bigint {
49394 if(!isWasmInitialized) {
49395 throw new Error("initializeWasm() must be awaited first!");
49397 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
49398 return nativeResponseValue;
49400 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
49402 export function EffectiveCapacity_as_msat(this_arg: bigint): bigint {
49403 if(!isWasmInitialized) {
49404 throw new Error("initializeWasm() must be awaited first!");
49406 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
49407 return nativeResponseValue;
49409 // void RoutingFees_free(struct LDKRoutingFees this_obj);
49411 export function RoutingFees_free(this_obj: bigint): void {
49412 if(!isWasmInitialized) {
49413 throw new Error("initializeWasm() must be awaited first!");
49415 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
49416 // debug statements here
49418 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
49420 export function RoutingFees_get_base_msat(this_ptr: bigint): number {
49421 if(!isWasmInitialized) {
49422 throw new Error("initializeWasm() must be awaited first!");
49424 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
49425 return nativeResponseValue;
49427 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
49429 export function RoutingFees_set_base_msat(this_ptr: bigint, val: number): void {
49430 if(!isWasmInitialized) {
49431 throw new Error("initializeWasm() must be awaited first!");
49433 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
49434 // debug statements here
49436 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
49438 export function RoutingFees_get_proportional_millionths(this_ptr: bigint): number {
49439 if(!isWasmInitialized) {
49440 throw new Error("initializeWasm() must be awaited first!");
49442 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
49443 return nativeResponseValue;
49445 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
49447 export function RoutingFees_set_proportional_millionths(this_ptr: bigint, val: number): void {
49448 if(!isWasmInitialized) {
49449 throw new Error("initializeWasm() must be awaited first!");
49451 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
49452 // debug statements here
49454 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
49456 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): bigint {
49457 if(!isWasmInitialized) {
49458 throw new Error("initializeWasm() must be awaited first!");
49460 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
49461 return nativeResponseValue;
49463 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
49465 export function RoutingFees_eq(a: bigint, b: bigint): boolean {
49466 if(!isWasmInitialized) {
49467 throw new Error("initializeWasm() must be awaited first!");
49469 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
49470 return nativeResponseValue;
49472 // uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
49474 export function RoutingFees_clone_ptr(arg: bigint): bigint {
49475 if(!isWasmInitialized) {
49476 throw new Error("initializeWasm() must be awaited first!");
49478 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
49479 return nativeResponseValue;
49481 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
49483 export function RoutingFees_clone(orig: bigint): bigint {
49484 if(!isWasmInitialized) {
49485 throw new Error("initializeWasm() must be awaited first!");
49487 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
49488 return nativeResponseValue;
49490 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
49492 export function RoutingFees_hash(o: bigint): bigint {
49493 if(!isWasmInitialized) {
49494 throw new Error("initializeWasm() must be awaited first!");
49496 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
49497 return nativeResponseValue;
49499 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
49501 export function RoutingFees_write(obj: bigint): number {
49502 if(!isWasmInitialized) {
49503 throw new Error("initializeWasm() must be awaited first!");
49505 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
49506 return nativeResponseValue;
49508 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
49510 export function RoutingFees_read(ser: number): bigint {
49511 if(!isWasmInitialized) {
49512 throw new Error("initializeWasm() must be awaited first!");
49514 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
49515 return nativeResponseValue;
49517 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
49519 export function NodeAnnouncementInfo_free(this_obj: bigint): void {
49520 if(!isWasmInitialized) {
49521 throw new Error("initializeWasm() must be awaited first!");
49523 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
49524 // debug statements here
49526 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
49528 export function NodeAnnouncementInfo_get_features(this_ptr: bigint): bigint {
49529 if(!isWasmInitialized) {
49530 throw new Error("initializeWasm() must be awaited first!");
49532 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
49533 return nativeResponseValue;
49535 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
49537 export function NodeAnnouncementInfo_set_features(this_ptr: bigint, val: bigint): void {
49538 if(!isWasmInitialized) {
49539 throw new Error("initializeWasm() must be awaited first!");
49541 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
49542 // debug statements here
49544 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
49546 export function NodeAnnouncementInfo_get_last_update(this_ptr: bigint): number {
49547 if(!isWasmInitialized) {
49548 throw new Error("initializeWasm() must be awaited first!");
49550 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
49551 return nativeResponseValue;
49553 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
49555 export function NodeAnnouncementInfo_set_last_update(this_ptr: bigint, val: number): void {
49556 if(!isWasmInitialized) {
49557 throw new Error("initializeWasm() must be awaited first!");
49559 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
49560 // debug statements here
49562 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
49564 export function NodeAnnouncementInfo_get_rgb(this_ptr: bigint): number {
49565 if(!isWasmInitialized) {
49566 throw new Error("initializeWasm() must be awaited first!");
49568 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
49569 return nativeResponseValue;
49571 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
49573 export function NodeAnnouncementInfo_set_rgb(this_ptr: bigint, val: number): void {
49574 if(!isWasmInitialized) {
49575 throw new Error("initializeWasm() must be awaited first!");
49577 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
49578 // debug statements here
49580 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
49582 export function NodeAnnouncementInfo_get_alias(this_ptr: bigint): bigint {
49583 if(!isWasmInitialized) {
49584 throw new Error("initializeWasm() must be awaited first!");
49586 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
49587 return nativeResponseValue;
49589 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
49591 export function NodeAnnouncementInfo_set_alias(this_ptr: bigint, val: bigint): void {
49592 if(!isWasmInitialized) {
49593 throw new Error("initializeWasm() must be awaited first!");
49595 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
49596 // debug statements here
49598 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
49600 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: bigint): bigint {
49601 if(!isWasmInitialized) {
49602 throw new Error("initializeWasm() must be awaited first!");
49604 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
49605 return nativeResponseValue;
49607 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
49609 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: bigint, val: bigint): void {
49610 if(!isWasmInitialized) {
49611 throw new Error("initializeWasm() must be awaited first!");
49613 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
49614 // debug statements here
49616 // 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);
49618 export function NodeAnnouncementInfo_new(features_arg: bigint, last_update_arg: number, rgb_arg: number, alias_arg: bigint, announcement_message_arg: bigint): bigint {
49619 if(!isWasmInitialized) {
49620 throw new Error("initializeWasm() must be awaited first!");
49622 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, announcement_message_arg);
49623 return nativeResponseValue;
49625 // uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
49627 export function NodeAnnouncementInfo_clone_ptr(arg: bigint): bigint {
49628 if(!isWasmInitialized) {
49629 throw new Error("initializeWasm() must be awaited first!");
49631 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
49632 return nativeResponseValue;
49634 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
49636 export function NodeAnnouncementInfo_clone(orig: bigint): bigint {
49637 if(!isWasmInitialized) {
49638 throw new Error("initializeWasm() must be awaited first!");
49640 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
49641 return nativeResponseValue;
49643 // bool NodeAnnouncementInfo_eq(const struct LDKNodeAnnouncementInfo *NONNULL_PTR a, const struct LDKNodeAnnouncementInfo *NONNULL_PTR b);
49645 export function NodeAnnouncementInfo_eq(a: bigint, b: bigint): boolean {
49646 if(!isWasmInitialized) {
49647 throw new Error("initializeWasm() must be awaited first!");
49649 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_eq(a, b);
49650 return nativeResponseValue;
49652 // MUST_USE_RES struct LDKCVec_SocketAddressZ NodeAnnouncementInfo_addresses(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_arg);
49654 export function NodeAnnouncementInfo_addresses(this_arg: bigint): number {
49655 if(!isWasmInitialized) {
49656 throw new Error("initializeWasm() must be awaited first!");
49658 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_addresses(this_arg);
49659 return nativeResponseValue;
49661 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
49663 export function NodeAnnouncementInfo_write(obj: bigint): number {
49664 if(!isWasmInitialized) {
49665 throw new Error("initializeWasm() must be awaited first!");
49667 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
49668 return nativeResponseValue;
49670 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
49672 export function NodeAnnouncementInfo_read(ser: number): bigint {
49673 if(!isWasmInitialized) {
49674 throw new Error("initializeWasm() must be awaited first!");
49676 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
49677 return nativeResponseValue;
49679 // void NodeAlias_free(struct LDKNodeAlias this_obj);
49681 export function NodeAlias_free(this_obj: bigint): void {
49682 if(!isWasmInitialized) {
49683 throw new Error("initializeWasm() must be awaited first!");
49685 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
49686 // debug statements here
49688 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
49690 export function NodeAlias_get_a(this_ptr: bigint): number {
49691 if(!isWasmInitialized) {
49692 throw new Error("initializeWasm() must be awaited first!");
49694 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
49695 return nativeResponseValue;
49697 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
49699 export function NodeAlias_set_a(this_ptr: bigint, val: number): void {
49700 if(!isWasmInitialized) {
49701 throw new Error("initializeWasm() must be awaited first!");
49703 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
49704 // debug statements here
49706 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
49708 export function NodeAlias_new(a_arg: number): bigint {
49709 if(!isWasmInitialized) {
49710 throw new Error("initializeWasm() must be awaited first!");
49712 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
49713 return nativeResponseValue;
49715 // uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
49717 export function NodeAlias_clone_ptr(arg: bigint): bigint {
49718 if(!isWasmInitialized) {
49719 throw new Error("initializeWasm() must be awaited first!");
49721 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
49722 return nativeResponseValue;
49724 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
49726 export function NodeAlias_clone(orig: bigint): bigint {
49727 if(!isWasmInitialized) {
49728 throw new Error("initializeWasm() must be awaited first!");
49730 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
49731 return nativeResponseValue;
49733 // uint64_t NodeAlias_hash(const struct LDKNodeAlias *NONNULL_PTR o);
49735 export function NodeAlias_hash(o: bigint): bigint {
49736 if(!isWasmInitialized) {
49737 throw new Error("initializeWasm() must be awaited first!");
49739 const nativeResponseValue = wasm.TS_NodeAlias_hash(o);
49740 return nativeResponseValue;
49742 // bool NodeAlias_eq(const struct LDKNodeAlias *NONNULL_PTR a, const struct LDKNodeAlias *NONNULL_PTR b);
49744 export function NodeAlias_eq(a: bigint, b: bigint): boolean {
49745 if(!isWasmInitialized) {
49746 throw new Error("initializeWasm() must be awaited first!");
49748 const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
49749 return nativeResponseValue;
49751 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
49753 export function NodeAlias_write(obj: bigint): number {
49754 if(!isWasmInitialized) {
49755 throw new Error("initializeWasm() must be awaited first!");
49757 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
49758 return nativeResponseValue;
49760 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
49762 export function NodeAlias_read(ser: number): bigint {
49763 if(!isWasmInitialized) {
49764 throw new Error("initializeWasm() must be awaited first!");
49766 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
49767 return nativeResponseValue;
49769 // void NodeInfo_free(struct LDKNodeInfo this_obj);
49771 export function NodeInfo_free(this_obj: bigint): void {
49772 if(!isWasmInitialized) {
49773 throw new Error("initializeWasm() must be awaited first!");
49775 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
49776 // debug statements here
49778 // struct LDKCVec_u64Z NodeInfo_get_channels(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
49780 export function NodeInfo_get_channels(this_ptr: bigint): number {
49781 if(!isWasmInitialized) {
49782 throw new Error("initializeWasm() must be awaited first!");
49784 const nativeResponseValue = wasm.TS_NodeInfo_get_channels(this_ptr);
49785 return nativeResponseValue;
49787 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
49789 export function NodeInfo_set_channels(this_ptr: bigint, val: number): void {
49790 if(!isWasmInitialized) {
49791 throw new Error("initializeWasm() must be awaited first!");
49793 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
49794 // debug statements here
49796 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
49798 export function NodeInfo_get_announcement_info(this_ptr: bigint): bigint {
49799 if(!isWasmInitialized) {
49800 throw new Error("initializeWasm() must be awaited first!");
49802 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
49803 return nativeResponseValue;
49805 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
49807 export function NodeInfo_set_announcement_info(this_ptr: bigint, val: bigint): void {
49808 if(!isWasmInitialized) {
49809 throw new Error("initializeWasm() must be awaited first!");
49811 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
49812 // debug statements here
49814 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
49816 export function NodeInfo_new(channels_arg: number, announcement_info_arg: bigint): bigint {
49817 if(!isWasmInitialized) {
49818 throw new Error("initializeWasm() must be awaited first!");
49820 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, announcement_info_arg);
49821 return nativeResponseValue;
49823 // uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
49825 export function NodeInfo_clone_ptr(arg: bigint): bigint {
49826 if(!isWasmInitialized) {
49827 throw new Error("initializeWasm() must be awaited first!");
49829 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
49830 return nativeResponseValue;
49832 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
49834 export function NodeInfo_clone(orig: bigint): bigint {
49835 if(!isWasmInitialized) {
49836 throw new Error("initializeWasm() must be awaited first!");
49838 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
49839 return nativeResponseValue;
49841 // bool NodeInfo_eq(const struct LDKNodeInfo *NONNULL_PTR a, const struct LDKNodeInfo *NONNULL_PTR b);
49843 export function NodeInfo_eq(a: bigint, b: bigint): boolean {
49844 if(!isWasmInitialized) {
49845 throw new Error("initializeWasm() must be awaited first!");
49847 const nativeResponseValue = wasm.TS_NodeInfo_eq(a, b);
49848 return nativeResponseValue;
49850 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
49852 export function NodeInfo_write(obj: bigint): number {
49853 if(!isWasmInitialized) {
49854 throw new Error("initializeWasm() must be awaited first!");
49856 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
49857 return nativeResponseValue;
49859 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
49861 export function NodeInfo_read(ser: number): bigint {
49862 if(!isWasmInitialized) {
49863 throw new Error("initializeWasm() must be awaited first!");
49865 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
49866 return nativeResponseValue;
49868 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
49870 export function NetworkGraph_write(obj: bigint): number {
49871 if(!isWasmInitialized) {
49872 throw new Error("initializeWasm() must be awaited first!");
49874 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
49875 return nativeResponseValue;
49877 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
49879 export function NetworkGraph_read(ser: number, arg: bigint): bigint {
49880 if(!isWasmInitialized) {
49881 throw new Error("initializeWasm() must be awaited first!");
49883 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
49884 return nativeResponseValue;
49886 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(enum LDKNetwork network, struct LDKLogger logger);
49888 export function NetworkGraph_new(network: Network, logger: bigint): bigint {
49889 if(!isWasmInitialized) {
49890 throw new Error("initializeWasm() must be awaited first!");
49892 const nativeResponseValue = wasm.TS_NetworkGraph_new(network, logger);
49893 return nativeResponseValue;
49895 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
49897 export function NetworkGraph_read_only(this_arg: bigint): bigint {
49898 if(!isWasmInitialized) {
49899 throw new Error("initializeWasm() must be awaited first!");
49901 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
49902 return nativeResponseValue;
49904 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
49906 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: bigint): bigint {
49907 if(!isWasmInitialized) {
49908 throw new Error("initializeWasm() must be awaited first!");
49910 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
49911 return nativeResponseValue;
49913 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
49915 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: bigint, last_rapid_gossip_sync_timestamp: number): void {
49916 if(!isWasmInitialized) {
49917 throw new Error("initializeWasm() must be awaited first!");
49919 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
49920 // debug statements here
49922 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
49924 export function NetworkGraph_update_node_from_announcement(this_arg: bigint, msg: bigint): bigint {
49925 if(!isWasmInitialized) {
49926 throw new Error("initializeWasm() must be awaited first!");
49928 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
49929 return nativeResponseValue;
49931 // 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);
49933 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: bigint, msg: bigint): bigint {
49934 if(!isWasmInitialized) {
49935 throw new Error("initializeWasm() must be awaited first!");
49937 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
49938 return nativeResponseValue;
49940 // 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);
49942 export function NetworkGraph_update_channel_from_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
49943 if(!isWasmInitialized) {
49944 throw new Error("initializeWasm() must be awaited first!");
49946 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, utxo_lookup);
49947 return nativeResponseValue;
49949 // 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);
49951 export function NetworkGraph_update_channel_from_announcement_no_lookup(this_arg: bigint, msg: bigint): bigint {
49952 if(!isWasmInitialized) {
49953 throw new Error("initializeWasm() must be awaited first!");
49955 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement_no_lookup(this_arg, msg);
49956 return nativeResponseValue;
49958 // 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);
49960 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: bigint, msg: bigint, utxo_lookup: bigint): bigint {
49961 if(!isWasmInitialized) {
49962 throw new Error("initializeWasm() must be awaited first!");
49964 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, utxo_lookup);
49965 return nativeResponseValue;
49967 // 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);
49969 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 {
49970 if(!isWasmInitialized) {
49971 throw new Error("initializeWasm() must be awaited first!");
49973 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
49974 return nativeResponseValue;
49976 // void NetworkGraph_channel_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
49978 export function NetworkGraph_channel_failed_permanent(this_arg: bigint, short_channel_id: bigint): void {
49979 if(!isWasmInitialized) {
49980 throw new Error("initializeWasm() must be awaited first!");
49982 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed_permanent(this_arg, short_channel_id);
49983 // debug statements here
49985 // void NetworkGraph_node_failed_permanent(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey node_id);
49987 export function NetworkGraph_node_failed_permanent(this_arg: bigint, node_id: number): void {
49988 if(!isWasmInitialized) {
49989 throw new Error("initializeWasm() must be awaited first!");
49991 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed_permanent(this_arg, node_id);
49992 // debug statements here
49994 // void NetworkGraph_remove_stale_channels_and_tracking_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
49996 export function NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg: bigint, current_time_unix: bigint): void {
49997 if(!isWasmInitialized) {
49998 throw new Error("initializeWasm() must be awaited first!");
50000 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_and_tracking_with_time(this_arg, current_time_unix);
50001 // debug statements here
50003 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
50005 export function NetworkGraph_update_channel(this_arg: bigint, msg: bigint): bigint {
50006 if(!isWasmInitialized) {
50007 throw new Error("initializeWasm() must be awaited first!");
50009 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
50010 return nativeResponseValue;
50012 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
50014 export function NetworkGraph_update_channel_unsigned(this_arg: bigint, msg: bigint): bigint {
50015 if(!isWasmInitialized) {
50016 throw new Error("initializeWasm() must be awaited first!");
50018 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
50019 return nativeResponseValue;
50021 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_verify_channel_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
50023 export function NetworkGraph_verify_channel_update(this_arg: bigint, msg: bigint): bigint {
50024 if(!isWasmInitialized) {
50025 throw new Error("initializeWasm() must be awaited first!");
50027 const nativeResponseValue = wasm.TS_NetworkGraph_verify_channel_update(this_arg, msg);
50028 return nativeResponseValue;
50030 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
50032 export function ReadOnlyNetworkGraph_channel(this_arg: bigint, short_channel_id: bigint): bigint {
50033 if(!isWasmInitialized) {
50034 throw new Error("initializeWasm() must be awaited first!");
50036 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
50037 return nativeResponseValue;
50039 // MUST_USE_RES struct LDKCVec_u64Z ReadOnlyNetworkGraph_list_channels(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
50041 export function ReadOnlyNetworkGraph_list_channels(this_arg: bigint): number {
50042 if(!isWasmInitialized) {
50043 throw new Error("initializeWasm() must be awaited first!");
50045 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_channels(this_arg);
50046 return nativeResponseValue;
50048 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
50050 export function ReadOnlyNetworkGraph_node(this_arg: bigint, node_id: bigint): bigint {
50051 if(!isWasmInitialized) {
50052 throw new Error("initializeWasm() must be awaited first!");
50054 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
50055 return nativeResponseValue;
50057 // MUST_USE_RES struct LDKCVec_NodeIdZ ReadOnlyNetworkGraph_list_nodes(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg);
50059 export function ReadOnlyNetworkGraph_list_nodes(this_arg: bigint): number {
50060 if(!isWasmInitialized) {
50061 throw new Error("initializeWasm() must be awaited first!");
50063 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_list_nodes(this_arg);
50064 return nativeResponseValue;
50066 // MUST_USE_RES struct LDKCOption_CVec_SocketAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
50068 export function ReadOnlyNetworkGraph_get_addresses(this_arg: bigint, pubkey: number): bigint {
50069 if(!isWasmInitialized) {
50070 throw new Error("initializeWasm() must be awaited first!");
50072 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
50073 return nativeResponseValue;
50075 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
50077 export function DefaultRouter_free(this_obj: bigint): void {
50078 if(!isWasmInitialized) {
50079 throw new Error("initializeWasm() must be awaited first!");
50081 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
50082 // debug statements here
50084 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKEntropySource entropy_source, struct LDKLockableScore scorer, struct LDKProbabilisticScoringFeeParameters score_params);
50086 export function DefaultRouter_new(network_graph: bigint, logger: bigint, entropy_source: bigint, scorer: bigint, score_params: bigint): bigint {
50087 if(!isWasmInitialized) {
50088 throw new Error("initializeWasm() must be awaited first!");
50090 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, entropy_source, scorer, score_params);
50091 return nativeResponseValue;
50093 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
50095 export function DefaultRouter_as_Router(this_arg: bigint): bigint {
50096 if(!isWasmInitialized) {
50097 throw new Error("initializeWasm() must be awaited first!");
50099 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
50100 return nativeResponseValue;
50102 // struct LDKMessageRouter DefaultRouter_as_MessageRouter(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
50104 export function DefaultRouter_as_MessageRouter(this_arg: bigint): bigint {
50105 if(!isWasmInitialized) {
50106 throw new Error("initializeWasm() must be awaited first!");
50108 const nativeResponseValue = wasm.TS_DefaultRouter_as_MessageRouter(this_arg);
50109 return nativeResponseValue;
50111 // void Router_free(struct LDKRouter this_ptr);
50113 export function Router_free(this_ptr: bigint): void {
50114 if(!isWasmInitialized) {
50115 throw new Error("initializeWasm() must be awaited first!");
50117 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
50118 // debug statements here
50120 // void ScorerAccountingForInFlightHtlcs_free(struct LDKScorerAccountingForInFlightHtlcs this_obj);
50122 export function ScorerAccountingForInFlightHtlcs_free(this_obj: bigint): void {
50123 if(!isWasmInitialized) {
50124 throw new Error("initializeWasm() must be awaited first!");
50126 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_free(this_obj);
50127 // debug statements here
50129 // MUST_USE_RES struct LDKScorerAccountingForInFlightHtlcs ScorerAccountingForInFlightHtlcs_new(struct LDKScoreLookUp scorer, const struct LDKInFlightHtlcs *NONNULL_PTR inflight_htlcs);
50131 export function ScorerAccountingForInFlightHtlcs_new(scorer: bigint, inflight_htlcs: bigint): bigint {
50132 if(!isWasmInitialized) {
50133 throw new Error("initializeWasm() must be awaited first!");
50135 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_new(scorer, inflight_htlcs);
50136 return nativeResponseValue;
50138 // struct LDKScoreLookUp ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(const struct LDKScorerAccountingForInFlightHtlcs *NONNULL_PTR this_arg);
50140 export function ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(this_arg: bigint): bigint {
50141 if(!isWasmInitialized) {
50142 throw new Error("initializeWasm() must be awaited first!");
50144 const nativeResponseValue = wasm.TS_ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(this_arg);
50145 return nativeResponseValue;
50147 // void InFlightHtlcs_free(struct LDKInFlightHtlcs this_obj);
50149 export function InFlightHtlcs_free(this_obj: bigint): void {
50150 if(!isWasmInitialized) {
50151 throw new Error("initializeWasm() must be awaited first!");
50153 const nativeResponseValue = wasm.TS_InFlightHtlcs_free(this_obj);
50154 // debug statements here
50156 // uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg);
50158 export function InFlightHtlcs_clone_ptr(arg: bigint): bigint {
50159 if(!isWasmInitialized) {
50160 throw new Error("initializeWasm() must be awaited first!");
50162 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone_ptr(arg);
50163 return nativeResponseValue;
50165 // struct LDKInFlightHtlcs InFlightHtlcs_clone(const struct LDKInFlightHtlcs *NONNULL_PTR orig);
50167 export function InFlightHtlcs_clone(orig: bigint): bigint {
50168 if(!isWasmInitialized) {
50169 throw new Error("initializeWasm() must be awaited first!");
50171 const nativeResponseValue = wasm.TS_InFlightHtlcs_clone(orig);
50172 return nativeResponseValue;
50174 // MUST_USE_RES struct LDKInFlightHtlcs InFlightHtlcs_new(void);
50176 export function InFlightHtlcs_new(): bigint {
50177 if(!isWasmInitialized) {
50178 throw new Error("initializeWasm() must be awaited first!");
50180 const nativeResponseValue = wasm.TS_InFlightHtlcs_new();
50181 return nativeResponseValue;
50183 // void InFlightHtlcs_process_path(struct LDKInFlightHtlcs *NONNULL_PTR this_arg, const struct LDKPath *NONNULL_PTR path, struct LDKPublicKey payer_node_id);
50185 export function InFlightHtlcs_process_path(this_arg: bigint, path: bigint, payer_node_id: number): void {
50186 if(!isWasmInitialized) {
50187 throw new Error("initializeWasm() must be awaited first!");
50189 const nativeResponseValue = wasm.TS_InFlightHtlcs_process_path(this_arg, path, payer_node_id);
50190 // debug statements here
50192 // 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);
50194 export function InFlightHtlcs_add_inflight_htlc(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint, used_msat: bigint): void {
50195 if(!isWasmInitialized) {
50196 throw new Error("initializeWasm() must be awaited first!");
50198 const nativeResponseValue = wasm.TS_InFlightHtlcs_add_inflight_htlc(this_arg, source, target, channel_scid, used_msat);
50199 // debug statements here
50201 // 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);
50203 export function InFlightHtlcs_used_liquidity_msat(this_arg: bigint, source: bigint, target: bigint, channel_scid: bigint): bigint {
50204 if(!isWasmInitialized) {
50205 throw new Error("initializeWasm() must be awaited first!");
50207 const nativeResponseValue = wasm.TS_InFlightHtlcs_used_liquidity_msat(this_arg, source, target, channel_scid);
50208 return nativeResponseValue;
50210 // struct LDKCVec_u8Z InFlightHtlcs_write(const struct LDKInFlightHtlcs *NONNULL_PTR obj);
50212 export function InFlightHtlcs_write(obj: bigint): number {
50213 if(!isWasmInitialized) {
50214 throw new Error("initializeWasm() must be awaited first!");
50216 const nativeResponseValue = wasm.TS_InFlightHtlcs_write(obj);
50217 return nativeResponseValue;
50219 // struct LDKCResult_InFlightHtlcsDecodeErrorZ InFlightHtlcs_read(struct LDKu8slice ser);
50221 export function InFlightHtlcs_read(ser: number): bigint {
50222 if(!isWasmInitialized) {
50223 throw new Error("initializeWasm() must be awaited first!");
50225 const nativeResponseValue = wasm.TS_InFlightHtlcs_read(ser);
50226 return nativeResponseValue;
50228 // void RouteHop_free(struct LDKRouteHop this_obj);
50230 export function RouteHop_free(this_obj: bigint): void {
50231 if(!isWasmInitialized) {
50232 throw new Error("initializeWasm() must be awaited first!");
50234 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
50235 // debug statements here
50237 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
50239 export function RouteHop_get_pubkey(this_ptr: bigint): number {
50240 if(!isWasmInitialized) {
50241 throw new Error("initializeWasm() must be awaited first!");
50243 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
50244 return nativeResponseValue;
50246 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
50248 export function RouteHop_set_pubkey(this_ptr: bigint, val: number): void {
50249 if(!isWasmInitialized) {
50250 throw new Error("initializeWasm() must be awaited first!");
50252 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
50253 // debug statements here
50255 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
50257 export function RouteHop_get_node_features(this_ptr: bigint): bigint {
50258 if(!isWasmInitialized) {
50259 throw new Error("initializeWasm() must be awaited first!");
50261 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
50262 return nativeResponseValue;
50264 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
50266 export function RouteHop_set_node_features(this_ptr: bigint, val: bigint): void {
50267 if(!isWasmInitialized) {
50268 throw new Error("initializeWasm() must be awaited first!");
50270 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
50271 // debug statements here
50273 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
50275 export function RouteHop_get_short_channel_id(this_ptr: bigint): bigint {
50276 if(!isWasmInitialized) {
50277 throw new Error("initializeWasm() must be awaited first!");
50279 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
50280 return nativeResponseValue;
50282 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
50284 export function RouteHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
50285 if(!isWasmInitialized) {
50286 throw new Error("initializeWasm() must be awaited first!");
50288 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
50289 // debug statements here
50291 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
50293 export function RouteHop_get_channel_features(this_ptr: bigint): bigint {
50294 if(!isWasmInitialized) {
50295 throw new Error("initializeWasm() must be awaited first!");
50297 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
50298 return nativeResponseValue;
50300 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
50302 export function RouteHop_set_channel_features(this_ptr: bigint, val: bigint): void {
50303 if(!isWasmInitialized) {
50304 throw new Error("initializeWasm() must be awaited first!");
50306 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
50307 // debug statements here
50309 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
50311 export function RouteHop_get_fee_msat(this_ptr: bigint): bigint {
50312 if(!isWasmInitialized) {
50313 throw new Error("initializeWasm() must be awaited first!");
50315 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
50316 return nativeResponseValue;
50318 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
50320 export function RouteHop_set_fee_msat(this_ptr: bigint, val: bigint): void {
50321 if(!isWasmInitialized) {
50322 throw new Error("initializeWasm() must be awaited first!");
50324 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
50325 // debug statements here
50327 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
50329 export function RouteHop_get_cltv_expiry_delta(this_ptr: bigint): number {
50330 if(!isWasmInitialized) {
50331 throw new Error("initializeWasm() must be awaited first!");
50333 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
50334 return nativeResponseValue;
50336 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
50338 export function RouteHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
50339 if(!isWasmInitialized) {
50340 throw new Error("initializeWasm() must be awaited first!");
50342 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
50343 // debug statements here
50345 // bool RouteHop_get_maybe_announced_channel(const struct LDKRouteHop *NONNULL_PTR this_ptr);
50347 export function RouteHop_get_maybe_announced_channel(this_ptr: bigint): boolean {
50348 if(!isWasmInitialized) {
50349 throw new Error("initializeWasm() must be awaited first!");
50351 const nativeResponseValue = wasm.TS_RouteHop_get_maybe_announced_channel(this_ptr);
50352 return nativeResponseValue;
50354 // void RouteHop_set_maybe_announced_channel(struct LDKRouteHop *NONNULL_PTR this_ptr, bool val);
50356 export function RouteHop_set_maybe_announced_channel(this_ptr: bigint, val: boolean): void {
50357 if(!isWasmInitialized) {
50358 throw new Error("initializeWasm() must be awaited first!");
50360 const nativeResponseValue = wasm.TS_RouteHop_set_maybe_announced_channel(this_ptr, val);
50361 // debug statements here
50363 // 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);
50365 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 {
50366 if(!isWasmInitialized) {
50367 throw new Error("initializeWasm() must be awaited first!");
50369 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);
50370 return nativeResponseValue;
50372 // uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
50374 export function RouteHop_clone_ptr(arg: bigint): bigint {
50375 if(!isWasmInitialized) {
50376 throw new Error("initializeWasm() must be awaited first!");
50378 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
50379 return nativeResponseValue;
50381 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
50383 export function RouteHop_clone(orig: bigint): bigint {
50384 if(!isWasmInitialized) {
50385 throw new Error("initializeWasm() must be awaited first!");
50387 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
50388 return nativeResponseValue;
50390 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
50392 export function RouteHop_hash(o: bigint): bigint {
50393 if(!isWasmInitialized) {
50394 throw new Error("initializeWasm() must be awaited first!");
50396 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
50397 return nativeResponseValue;
50399 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
50401 export function RouteHop_eq(a: bigint, b: bigint): boolean {
50402 if(!isWasmInitialized) {
50403 throw new Error("initializeWasm() must be awaited first!");
50405 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
50406 return nativeResponseValue;
50408 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
50410 export function RouteHop_write(obj: bigint): number {
50411 if(!isWasmInitialized) {
50412 throw new Error("initializeWasm() must be awaited first!");
50414 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
50415 return nativeResponseValue;
50417 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
50419 export function RouteHop_read(ser: number): bigint {
50420 if(!isWasmInitialized) {
50421 throw new Error("initializeWasm() must be awaited first!");
50423 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
50424 return nativeResponseValue;
50426 // void BlindedTail_free(struct LDKBlindedTail this_obj);
50428 export function BlindedTail_free(this_obj: bigint): void {
50429 if(!isWasmInitialized) {
50430 throw new Error("initializeWasm() must be awaited first!");
50432 const nativeResponseValue = wasm.TS_BlindedTail_free(this_obj);
50433 // debug statements here
50435 // struct LDKCVec_BlindedHopZ BlindedTail_get_hops(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
50437 export function BlindedTail_get_hops(this_ptr: bigint): number {
50438 if(!isWasmInitialized) {
50439 throw new Error("initializeWasm() must be awaited first!");
50441 const nativeResponseValue = wasm.TS_BlindedTail_get_hops(this_ptr);
50442 return nativeResponseValue;
50444 // void BlindedTail_set_hops(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKCVec_BlindedHopZ val);
50446 export function BlindedTail_set_hops(this_ptr: bigint, val: number): void {
50447 if(!isWasmInitialized) {
50448 throw new Error("initializeWasm() must be awaited first!");
50450 const nativeResponseValue = wasm.TS_BlindedTail_set_hops(this_ptr, val);
50451 // debug statements here
50453 // struct LDKPublicKey BlindedTail_get_blinding_point(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
50455 export function BlindedTail_get_blinding_point(this_ptr: bigint): number {
50456 if(!isWasmInitialized) {
50457 throw new Error("initializeWasm() must be awaited first!");
50459 const nativeResponseValue = wasm.TS_BlindedTail_get_blinding_point(this_ptr);
50460 return nativeResponseValue;
50462 // void BlindedTail_set_blinding_point(struct LDKBlindedTail *NONNULL_PTR this_ptr, struct LDKPublicKey val);
50464 export function BlindedTail_set_blinding_point(this_ptr: bigint, val: number): void {
50465 if(!isWasmInitialized) {
50466 throw new Error("initializeWasm() must be awaited first!");
50468 const nativeResponseValue = wasm.TS_BlindedTail_set_blinding_point(this_ptr, val);
50469 // debug statements here
50471 // uint32_t BlindedTail_get_excess_final_cltv_expiry_delta(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
50473 export function BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr: bigint): number {
50474 if(!isWasmInitialized) {
50475 throw new Error("initializeWasm() must be awaited first!");
50477 const nativeResponseValue = wasm.TS_BlindedTail_get_excess_final_cltv_expiry_delta(this_ptr);
50478 return nativeResponseValue;
50480 // void BlindedTail_set_excess_final_cltv_expiry_delta(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint32_t val);
50482 export function BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr: bigint, val: number): void {
50483 if(!isWasmInitialized) {
50484 throw new Error("initializeWasm() must be awaited first!");
50486 const nativeResponseValue = wasm.TS_BlindedTail_set_excess_final_cltv_expiry_delta(this_ptr, val);
50487 // debug statements here
50489 // uint64_t BlindedTail_get_final_value_msat(const struct LDKBlindedTail *NONNULL_PTR this_ptr);
50491 export function BlindedTail_get_final_value_msat(this_ptr: bigint): bigint {
50492 if(!isWasmInitialized) {
50493 throw new Error("initializeWasm() must be awaited first!");
50495 const nativeResponseValue = wasm.TS_BlindedTail_get_final_value_msat(this_ptr);
50496 return nativeResponseValue;
50498 // void BlindedTail_set_final_value_msat(struct LDKBlindedTail *NONNULL_PTR this_ptr, uint64_t val);
50500 export function BlindedTail_set_final_value_msat(this_ptr: bigint, val: bigint): void {
50501 if(!isWasmInitialized) {
50502 throw new Error("initializeWasm() must be awaited first!");
50504 const nativeResponseValue = wasm.TS_BlindedTail_set_final_value_msat(this_ptr, val);
50505 // debug statements here
50507 // 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);
50509 export function BlindedTail_new(hops_arg: number, blinding_point_arg: number, excess_final_cltv_expiry_delta_arg: number, final_value_msat_arg: bigint): bigint {
50510 if(!isWasmInitialized) {
50511 throw new Error("initializeWasm() must be awaited first!");
50513 const nativeResponseValue = wasm.TS_BlindedTail_new(hops_arg, blinding_point_arg, excess_final_cltv_expiry_delta_arg, final_value_msat_arg);
50514 return nativeResponseValue;
50516 // uint64_t BlindedTail_clone_ptr(LDKBlindedTail *NONNULL_PTR arg);
50518 export function BlindedTail_clone_ptr(arg: bigint): bigint {
50519 if(!isWasmInitialized) {
50520 throw new Error("initializeWasm() must be awaited first!");
50522 const nativeResponseValue = wasm.TS_BlindedTail_clone_ptr(arg);
50523 return nativeResponseValue;
50525 // struct LDKBlindedTail BlindedTail_clone(const struct LDKBlindedTail *NONNULL_PTR orig);
50527 export function BlindedTail_clone(orig: bigint): bigint {
50528 if(!isWasmInitialized) {
50529 throw new Error("initializeWasm() must be awaited first!");
50531 const nativeResponseValue = wasm.TS_BlindedTail_clone(orig);
50532 return nativeResponseValue;
50534 // uint64_t BlindedTail_hash(const struct LDKBlindedTail *NONNULL_PTR o);
50536 export function BlindedTail_hash(o: bigint): bigint {
50537 if(!isWasmInitialized) {
50538 throw new Error("initializeWasm() must be awaited first!");
50540 const nativeResponseValue = wasm.TS_BlindedTail_hash(o);
50541 return nativeResponseValue;
50543 // bool BlindedTail_eq(const struct LDKBlindedTail *NONNULL_PTR a, const struct LDKBlindedTail *NONNULL_PTR b);
50545 export function BlindedTail_eq(a: bigint, b: bigint): boolean {
50546 if(!isWasmInitialized) {
50547 throw new Error("initializeWasm() must be awaited first!");
50549 const nativeResponseValue = wasm.TS_BlindedTail_eq(a, b);
50550 return nativeResponseValue;
50552 // struct LDKCVec_u8Z BlindedTail_write(const struct LDKBlindedTail *NONNULL_PTR obj);
50554 export function BlindedTail_write(obj: bigint): number {
50555 if(!isWasmInitialized) {
50556 throw new Error("initializeWasm() must be awaited first!");
50558 const nativeResponseValue = wasm.TS_BlindedTail_write(obj);
50559 return nativeResponseValue;
50561 // struct LDKCResult_BlindedTailDecodeErrorZ BlindedTail_read(struct LDKu8slice ser);
50563 export function BlindedTail_read(ser: number): bigint {
50564 if(!isWasmInitialized) {
50565 throw new Error("initializeWasm() must be awaited first!");
50567 const nativeResponseValue = wasm.TS_BlindedTail_read(ser);
50568 return nativeResponseValue;
50570 // void Path_free(struct LDKPath this_obj);
50572 export function Path_free(this_obj: bigint): void {
50573 if(!isWasmInitialized) {
50574 throw new Error("initializeWasm() must be awaited first!");
50576 const nativeResponseValue = wasm.TS_Path_free(this_obj);
50577 // debug statements here
50579 // struct LDKCVec_RouteHopZ Path_get_hops(const struct LDKPath *NONNULL_PTR this_ptr);
50581 export function Path_get_hops(this_ptr: bigint): number {
50582 if(!isWasmInitialized) {
50583 throw new Error("initializeWasm() must be awaited first!");
50585 const nativeResponseValue = wasm.TS_Path_get_hops(this_ptr);
50586 return nativeResponseValue;
50588 // void Path_set_hops(struct LDKPath *NONNULL_PTR this_ptr, struct LDKCVec_RouteHopZ val);
50590 export function Path_set_hops(this_ptr: bigint, val: number): void {
50591 if(!isWasmInitialized) {
50592 throw new Error("initializeWasm() must be awaited first!");
50594 const nativeResponseValue = wasm.TS_Path_set_hops(this_ptr, val);
50595 // debug statements here
50597 // struct LDKBlindedTail Path_get_blinded_tail(const struct LDKPath *NONNULL_PTR this_ptr);
50599 export function Path_get_blinded_tail(this_ptr: bigint): bigint {
50600 if(!isWasmInitialized) {
50601 throw new Error("initializeWasm() must be awaited first!");
50603 const nativeResponseValue = wasm.TS_Path_get_blinded_tail(this_ptr);
50604 return nativeResponseValue;
50606 // void Path_set_blinded_tail(struct LDKPath *NONNULL_PTR this_ptr, struct LDKBlindedTail val);
50608 export function Path_set_blinded_tail(this_ptr: bigint, val: bigint): void {
50609 if(!isWasmInitialized) {
50610 throw new Error("initializeWasm() must be awaited first!");
50612 const nativeResponseValue = wasm.TS_Path_set_blinded_tail(this_ptr, val);
50613 // debug statements here
50615 // MUST_USE_RES struct LDKPath Path_new(struct LDKCVec_RouteHopZ hops_arg, struct LDKBlindedTail blinded_tail_arg);
50617 export function Path_new(hops_arg: number, blinded_tail_arg: bigint): bigint {
50618 if(!isWasmInitialized) {
50619 throw new Error("initializeWasm() must be awaited first!");
50621 const nativeResponseValue = wasm.TS_Path_new(hops_arg, blinded_tail_arg);
50622 return nativeResponseValue;
50624 // uint64_t Path_clone_ptr(LDKPath *NONNULL_PTR arg);
50626 export function Path_clone_ptr(arg: bigint): bigint {
50627 if(!isWasmInitialized) {
50628 throw new Error("initializeWasm() must be awaited first!");
50630 const nativeResponseValue = wasm.TS_Path_clone_ptr(arg);
50631 return nativeResponseValue;
50633 // struct LDKPath Path_clone(const struct LDKPath *NONNULL_PTR orig);
50635 export function Path_clone(orig: bigint): bigint {
50636 if(!isWasmInitialized) {
50637 throw new Error("initializeWasm() must be awaited first!");
50639 const nativeResponseValue = wasm.TS_Path_clone(orig);
50640 return nativeResponseValue;
50642 // uint64_t Path_hash(const struct LDKPath *NONNULL_PTR o);
50644 export function Path_hash(o: bigint): bigint {
50645 if(!isWasmInitialized) {
50646 throw new Error("initializeWasm() must be awaited first!");
50648 const nativeResponseValue = wasm.TS_Path_hash(o);
50649 return nativeResponseValue;
50651 // bool Path_eq(const struct LDKPath *NONNULL_PTR a, const struct LDKPath *NONNULL_PTR b);
50653 export function Path_eq(a: bigint, b: bigint): boolean {
50654 if(!isWasmInitialized) {
50655 throw new Error("initializeWasm() must be awaited first!");
50657 const nativeResponseValue = wasm.TS_Path_eq(a, b);
50658 return nativeResponseValue;
50660 // MUST_USE_RES uint64_t Path_fee_msat(const struct LDKPath *NONNULL_PTR this_arg);
50662 export function Path_fee_msat(this_arg: bigint): bigint {
50663 if(!isWasmInitialized) {
50664 throw new Error("initializeWasm() must be awaited first!");
50666 const nativeResponseValue = wasm.TS_Path_fee_msat(this_arg);
50667 return nativeResponseValue;
50669 // MUST_USE_RES uint64_t Path_final_value_msat(const struct LDKPath *NONNULL_PTR this_arg);
50671 export function Path_final_value_msat(this_arg: bigint): bigint {
50672 if(!isWasmInitialized) {
50673 throw new Error("initializeWasm() must be awaited first!");
50675 const nativeResponseValue = wasm.TS_Path_final_value_msat(this_arg);
50676 return nativeResponseValue;
50678 // MUST_USE_RES struct LDKCOption_u32Z Path_final_cltv_expiry_delta(const struct LDKPath *NONNULL_PTR this_arg);
50680 export function Path_final_cltv_expiry_delta(this_arg: bigint): bigint {
50681 if(!isWasmInitialized) {
50682 throw new Error("initializeWasm() must be awaited first!");
50684 const nativeResponseValue = wasm.TS_Path_final_cltv_expiry_delta(this_arg);
50685 return nativeResponseValue;
50687 // void Route_free(struct LDKRoute this_obj);
50689 export function Route_free(this_obj: bigint): void {
50690 if(!isWasmInitialized) {
50691 throw new Error("initializeWasm() must be awaited first!");
50693 const nativeResponseValue = wasm.TS_Route_free(this_obj);
50694 // debug statements here
50696 // struct LDKCVec_PathZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
50698 export function Route_get_paths(this_ptr: bigint): number {
50699 if(!isWasmInitialized) {
50700 throw new Error("initializeWasm() must be awaited first!");
50702 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
50703 return nativeResponseValue;
50705 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_PathZ val);
50707 export function Route_set_paths(this_ptr: bigint, val: number): void {
50708 if(!isWasmInitialized) {
50709 throw new Error("initializeWasm() must be awaited first!");
50711 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
50712 // debug statements here
50714 // struct LDKRouteParameters Route_get_route_params(const struct LDKRoute *NONNULL_PTR this_ptr);
50716 export function Route_get_route_params(this_ptr: bigint): bigint {
50717 if(!isWasmInitialized) {
50718 throw new Error("initializeWasm() must be awaited first!");
50720 const nativeResponseValue = wasm.TS_Route_get_route_params(this_ptr);
50721 return nativeResponseValue;
50723 // void Route_set_route_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKRouteParameters val);
50725 export function Route_set_route_params(this_ptr: bigint, val: bigint): void {
50726 if(!isWasmInitialized) {
50727 throw new Error("initializeWasm() must be awaited first!");
50729 const nativeResponseValue = wasm.TS_Route_set_route_params(this_ptr, val);
50730 // debug statements here
50732 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_PathZ paths_arg, struct LDKRouteParameters route_params_arg);
50734 export function Route_new(paths_arg: number, route_params_arg: bigint): bigint {
50735 if(!isWasmInitialized) {
50736 throw new Error("initializeWasm() must be awaited first!");
50738 const nativeResponseValue = wasm.TS_Route_new(paths_arg, route_params_arg);
50739 return nativeResponseValue;
50741 // uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
50743 export function Route_clone_ptr(arg: bigint): bigint {
50744 if(!isWasmInitialized) {
50745 throw new Error("initializeWasm() must be awaited first!");
50747 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
50748 return nativeResponseValue;
50750 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
50752 export function Route_clone(orig: bigint): bigint {
50753 if(!isWasmInitialized) {
50754 throw new Error("initializeWasm() must be awaited first!");
50756 const nativeResponseValue = wasm.TS_Route_clone(orig);
50757 return nativeResponseValue;
50759 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
50761 export function Route_hash(o: bigint): bigint {
50762 if(!isWasmInitialized) {
50763 throw new Error("initializeWasm() must be awaited first!");
50765 const nativeResponseValue = wasm.TS_Route_hash(o);
50766 return nativeResponseValue;
50768 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
50770 export function Route_eq(a: bigint, b: bigint): boolean {
50771 if(!isWasmInitialized) {
50772 throw new Error("initializeWasm() must be awaited first!");
50774 const nativeResponseValue = wasm.TS_Route_eq(a, b);
50775 return nativeResponseValue;
50777 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
50779 export function Route_get_total_fees(this_arg: bigint): bigint {
50780 if(!isWasmInitialized) {
50781 throw new Error("initializeWasm() must be awaited first!");
50783 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
50784 return nativeResponseValue;
50786 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
50788 export function Route_get_total_amount(this_arg: bigint): bigint {
50789 if(!isWasmInitialized) {
50790 throw new Error("initializeWasm() must be awaited first!");
50792 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
50793 return nativeResponseValue;
50795 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
50797 export function Route_write(obj: bigint): number {
50798 if(!isWasmInitialized) {
50799 throw new Error("initializeWasm() must be awaited first!");
50801 const nativeResponseValue = wasm.TS_Route_write(obj);
50802 return nativeResponseValue;
50804 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
50806 export function Route_read(ser: number): bigint {
50807 if(!isWasmInitialized) {
50808 throw new Error("initializeWasm() must be awaited first!");
50810 const nativeResponseValue = wasm.TS_Route_read(ser);
50811 return nativeResponseValue;
50813 // void RouteParameters_free(struct LDKRouteParameters this_obj);
50815 export function RouteParameters_free(this_obj: bigint): void {
50816 if(!isWasmInitialized) {
50817 throw new Error("initializeWasm() must be awaited first!");
50819 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
50820 // debug statements here
50822 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
50824 export function RouteParameters_get_payment_params(this_ptr: bigint): bigint {
50825 if(!isWasmInitialized) {
50826 throw new Error("initializeWasm() must be awaited first!");
50828 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
50829 return nativeResponseValue;
50831 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
50833 export function RouteParameters_set_payment_params(this_ptr: bigint, val: bigint): void {
50834 if(!isWasmInitialized) {
50835 throw new Error("initializeWasm() must be awaited first!");
50837 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
50838 // debug statements here
50840 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
50842 export function RouteParameters_get_final_value_msat(this_ptr: bigint): bigint {
50843 if(!isWasmInitialized) {
50844 throw new Error("initializeWasm() must be awaited first!");
50846 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
50847 return nativeResponseValue;
50849 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
50851 export function RouteParameters_set_final_value_msat(this_ptr: bigint, val: bigint): void {
50852 if(!isWasmInitialized) {
50853 throw new Error("initializeWasm() must be awaited first!");
50855 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
50856 // debug statements here
50858 // struct LDKCOption_u64Z RouteParameters_get_max_total_routing_fee_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
50860 export function RouteParameters_get_max_total_routing_fee_msat(this_ptr: bigint): bigint {
50861 if(!isWasmInitialized) {
50862 throw new Error("initializeWasm() must be awaited first!");
50864 const nativeResponseValue = wasm.TS_RouteParameters_get_max_total_routing_fee_msat(this_ptr);
50865 return nativeResponseValue;
50867 // void RouteParameters_set_max_total_routing_fee_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
50869 export function RouteParameters_set_max_total_routing_fee_msat(this_ptr: bigint, val: bigint): void {
50870 if(!isWasmInitialized) {
50871 throw new Error("initializeWasm() must be awaited first!");
50873 const nativeResponseValue = wasm.TS_RouteParameters_set_max_total_routing_fee_msat(this_ptr, val);
50874 // debug statements here
50876 // 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);
50878 export function RouteParameters_new(payment_params_arg: bigint, final_value_msat_arg: bigint, max_total_routing_fee_msat_arg: bigint): bigint {
50879 if(!isWasmInitialized) {
50880 throw new Error("initializeWasm() must be awaited first!");
50882 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, max_total_routing_fee_msat_arg);
50883 return nativeResponseValue;
50885 // uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
50887 export function RouteParameters_clone_ptr(arg: bigint): bigint {
50888 if(!isWasmInitialized) {
50889 throw new Error("initializeWasm() must be awaited first!");
50891 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
50892 return nativeResponseValue;
50894 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
50896 export function RouteParameters_clone(orig: bigint): bigint {
50897 if(!isWasmInitialized) {
50898 throw new Error("initializeWasm() must be awaited first!");
50900 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
50901 return nativeResponseValue;
50903 // uint64_t RouteParameters_hash(const struct LDKRouteParameters *NONNULL_PTR o);
50905 export function RouteParameters_hash(o: bigint): bigint {
50906 if(!isWasmInitialized) {
50907 throw new Error("initializeWasm() must be awaited first!");
50909 const nativeResponseValue = wasm.TS_RouteParameters_hash(o);
50910 return nativeResponseValue;
50912 // bool RouteParameters_eq(const struct LDKRouteParameters *NONNULL_PTR a, const struct LDKRouteParameters *NONNULL_PTR b);
50914 export function RouteParameters_eq(a: bigint, b: bigint): boolean {
50915 if(!isWasmInitialized) {
50916 throw new Error("initializeWasm() must be awaited first!");
50918 const nativeResponseValue = wasm.TS_RouteParameters_eq(a, b);
50919 return nativeResponseValue;
50921 // MUST_USE_RES struct LDKRouteParameters RouteParameters_from_payment_params_and_value(struct LDKPaymentParameters payment_params, uint64_t final_value_msat);
50923 export function RouteParameters_from_payment_params_and_value(payment_params: bigint, final_value_msat: bigint): bigint {
50924 if(!isWasmInitialized) {
50925 throw new Error("initializeWasm() must be awaited first!");
50927 const nativeResponseValue = wasm.TS_RouteParameters_from_payment_params_and_value(payment_params, final_value_msat);
50928 return nativeResponseValue;
50930 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
50932 export function RouteParameters_write(obj: bigint): number {
50933 if(!isWasmInitialized) {
50934 throw new Error("initializeWasm() must be awaited first!");
50936 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
50937 return nativeResponseValue;
50939 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
50941 export function RouteParameters_read(ser: number): bigint {
50942 if(!isWasmInitialized) {
50943 throw new Error("initializeWasm() must be awaited first!");
50945 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
50946 return nativeResponseValue;
50948 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
50950 export function PaymentParameters_free(this_obj: bigint): void {
50951 if(!isWasmInitialized) {
50952 throw new Error("initializeWasm() must be awaited first!");
50954 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
50955 // debug statements here
50957 // struct LDKPayee PaymentParameters_get_payee(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
50959 export function PaymentParameters_get_payee(this_ptr: bigint): bigint {
50960 if(!isWasmInitialized) {
50961 throw new Error("initializeWasm() must be awaited first!");
50963 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee(this_ptr);
50964 return nativeResponseValue;
50966 // void PaymentParameters_set_payee(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPayee val);
50968 export function PaymentParameters_set_payee(this_ptr: bigint, val: bigint): void {
50969 if(!isWasmInitialized) {
50970 throw new Error("initializeWasm() must be awaited first!");
50972 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee(this_ptr, val);
50973 // debug statements here
50975 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
50977 export function PaymentParameters_get_expiry_time(this_ptr: bigint): bigint {
50978 if(!isWasmInitialized) {
50979 throw new Error("initializeWasm() must be awaited first!");
50981 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
50982 return nativeResponseValue;
50984 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
50986 export function PaymentParameters_set_expiry_time(this_ptr: bigint, val: bigint): void {
50987 if(!isWasmInitialized) {
50988 throw new Error("initializeWasm() must be awaited first!");
50990 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
50991 // debug statements here
50993 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
50995 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: bigint): number {
50996 if(!isWasmInitialized) {
50997 throw new Error("initializeWasm() must be awaited first!");
50999 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
51000 return nativeResponseValue;
51002 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
51004 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: bigint, val: number): void {
51005 if(!isWasmInitialized) {
51006 throw new Error("initializeWasm() must be awaited first!");
51008 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
51009 // debug statements here
51011 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
51013 export function PaymentParameters_get_max_path_count(this_ptr: bigint): number {
51014 if(!isWasmInitialized) {
51015 throw new Error("initializeWasm() must be awaited first!");
51017 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
51018 return nativeResponseValue;
51020 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
51022 export function PaymentParameters_set_max_path_count(this_ptr: bigint, val: number): void {
51023 if(!isWasmInitialized) {
51024 throw new Error("initializeWasm() must be awaited first!");
51026 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
51027 // debug statements here
51029 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
51031 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: bigint): number {
51032 if(!isWasmInitialized) {
51033 throw new Error("initializeWasm() must be awaited first!");
51035 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
51036 return nativeResponseValue;
51038 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
51040 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: bigint, val: number): void {
51041 if(!isWasmInitialized) {
51042 throw new Error("initializeWasm() must be awaited first!");
51044 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
51045 // debug statements here
51047 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_channels(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
51049 export function PaymentParameters_get_previously_failed_channels(this_ptr: bigint): number {
51050 if(!isWasmInitialized) {
51051 throw new Error("initializeWasm() must be awaited first!");
51053 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_channels(this_ptr);
51054 return nativeResponseValue;
51056 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
51058 export function PaymentParameters_set_previously_failed_channels(this_ptr: bigint, val: number): void {
51059 if(!isWasmInitialized) {
51060 throw new Error("initializeWasm() must be awaited first!");
51062 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
51063 // debug statements here
51065 // struct LDKCVec_u64Z PaymentParameters_get_previously_failed_blinded_path_idxs(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
51067 export function PaymentParameters_get_previously_failed_blinded_path_idxs(this_ptr: bigint): number {
51068 if(!isWasmInitialized) {
51069 throw new Error("initializeWasm() must be awaited first!");
51071 const nativeResponseValue = wasm.TS_PaymentParameters_get_previously_failed_blinded_path_idxs(this_ptr);
51072 return nativeResponseValue;
51074 // void PaymentParameters_set_previously_failed_blinded_path_idxs(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
51076 export function PaymentParameters_set_previously_failed_blinded_path_idxs(this_ptr: bigint, val: number): void {
51077 if(!isWasmInitialized) {
51078 throw new Error("initializeWasm() must be awaited first!");
51080 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_blinded_path_idxs(this_ptr, val);
51081 // debug statements here
51083 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPayee payee_arg, struct LDKCOption_u64Z expiry_time_arg, uint32_t max_total_cltv_expiry_delta_arg, uint8_t max_path_count_arg, uint8_t max_channel_saturation_power_of_half_arg, struct LDKCVec_u64Z previously_failed_channels_arg, struct LDKCVec_u64Z previously_failed_blinded_path_idxs_arg);
51085 export function PaymentParameters_new(payee_arg: bigint, expiry_time_arg: bigint, max_total_cltv_expiry_delta_arg: number, max_path_count_arg: number, max_channel_saturation_power_of_half_arg: number, previously_failed_channels_arg: number, previously_failed_blinded_path_idxs_arg: number): bigint {
51086 if(!isWasmInitialized) {
51087 throw new Error("initializeWasm() must be awaited first!");
51089 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg, max_path_count_arg, max_channel_saturation_power_of_half_arg, previously_failed_channels_arg, previously_failed_blinded_path_idxs_arg);
51090 return nativeResponseValue;
51092 // uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
51094 export function PaymentParameters_clone_ptr(arg: bigint): bigint {
51095 if(!isWasmInitialized) {
51096 throw new Error("initializeWasm() must be awaited first!");
51098 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
51099 return nativeResponseValue;
51101 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
51103 export function PaymentParameters_clone(orig: bigint): bigint {
51104 if(!isWasmInitialized) {
51105 throw new Error("initializeWasm() must be awaited first!");
51107 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
51108 return nativeResponseValue;
51110 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
51112 export function PaymentParameters_hash(o: bigint): bigint {
51113 if(!isWasmInitialized) {
51114 throw new Error("initializeWasm() must be awaited first!");
51116 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
51117 return nativeResponseValue;
51119 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
51121 export function PaymentParameters_eq(a: bigint, b: bigint): boolean {
51122 if(!isWasmInitialized) {
51123 throw new Error("initializeWasm() must be awaited first!");
51125 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
51126 return nativeResponseValue;
51128 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
51130 export function PaymentParameters_write(obj: bigint): number {
51131 if(!isWasmInitialized) {
51132 throw new Error("initializeWasm() must be awaited first!");
51134 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
51135 return nativeResponseValue;
51137 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser, uint32_t arg);
51139 export function PaymentParameters_read(ser: number, arg: number): bigint {
51140 if(!isWasmInitialized) {
51141 throw new Error("initializeWasm() must be awaited first!");
51143 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser, arg);
51144 return nativeResponseValue;
51146 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta);
51148 export function PaymentParameters_from_node_id(payee_pubkey: number, final_cltv_expiry_delta: number): bigint {
51149 if(!isWasmInitialized) {
51150 throw new Error("initializeWasm() must be awaited first!");
51152 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey, final_cltv_expiry_delta);
51153 return nativeResponseValue;
51155 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey, uint32_t final_cltv_expiry_delta, bool allow_mpp);
51157 export function PaymentParameters_for_keysend(payee_pubkey: number, final_cltv_expiry_delta: number, allow_mpp: boolean): bigint {
51158 if(!isWasmInitialized) {
51159 throw new Error("initializeWasm() must be awaited first!");
51161 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey, final_cltv_expiry_delta, allow_mpp);
51162 return nativeResponseValue;
51164 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_bolt12_invoice(const struct LDKBolt12Invoice *NONNULL_PTR invoice);
51166 export function PaymentParameters_from_bolt12_invoice(invoice: bigint): bigint {
51167 if(!isWasmInitialized) {
51168 throw new Error("initializeWasm() must be awaited first!");
51170 const nativeResponseValue = wasm.TS_PaymentParameters_from_bolt12_invoice(invoice);
51171 return nativeResponseValue;
51173 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_blinded(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ blinded_route_hints);
51175 export function PaymentParameters_blinded(blinded_route_hints: number): bigint {
51176 if(!isWasmInitialized) {
51177 throw new Error("initializeWasm() must be awaited first!");
51179 const nativeResponseValue = wasm.TS_PaymentParameters_blinded(blinded_route_hints);
51180 return nativeResponseValue;
51182 // void Payee_free(struct LDKPayee this_ptr);
51184 export function Payee_free(this_ptr: bigint): void {
51185 if(!isWasmInitialized) {
51186 throw new Error("initializeWasm() must be awaited first!");
51188 const nativeResponseValue = wasm.TS_Payee_free(this_ptr);
51189 // debug statements here
51191 // uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg);
51193 export function Payee_clone_ptr(arg: bigint): bigint {
51194 if(!isWasmInitialized) {
51195 throw new Error("initializeWasm() must be awaited first!");
51197 const nativeResponseValue = wasm.TS_Payee_clone_ptr(arg);
51198 return nativeResponseValue;
51200 // struct LDKPayee Payee_clone(const struct LDKPayee *NONNULL_PTR orig);
51202 export function Payee_clone(orig: bigint): bigint {
51203 if(!isWasmInitialized) {
51204 throw new Error("initializeWasm() must be awaited first!");
51206 const nativeResponseValue = wasm.TS_Payee_clone(orig);
51207 return nativeResponseValue;
51209 // struct LDKPayee Payee_blinded(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ route_hints, struct LDKBolt12InvoiceFeatures features);
51211 export function Payee_blinded(route_hints: number, features: bigint): bigint {
51212 if(!isWasmInitialized) {
51213 throw new Error("initializeWasm() must be awaited first!");
51215 const nativeResponseValue = wasm.TS_Payee_blinded(route_hints, features);
51216 return nativeResponseValue;
51218 // struct LDKPayee Payee_clear(struct LDKPublicKey node_id, struct LDKCVec_RouteHintZ route_hints, struct LDKBolt11InvoiceFeatures features, uint32_t final_cltv_expiry_delta);
51220 export function Payee_clear(node_id: number, route_hints: number, features: bigint, final_cltv_expiry_delta: number): bigint {
51221 if(!isWasmInitialized) {
51222 throw new Error("initializeWasm() must be awaited first!");
51224 const nativeResponseValue = wasm.TS_Payee_clear(node_id, route_hints, features, final_cltv_expiry_delta);
51225 return nativeResponseValue;
51227 // uint64_t Payee_hash(const struct LDKPayee *NONNULL_PTR o);
51229 export function Payee_hash(o: bigint): bigint {
51230 if(!isWasmInitialized) {
51231 throw new Error("initializeWasm() must be awaited first!");
51233 const nativeResponseValue = wasm.TS_Payee_hash(o);
51234 return nativeResponseValue;
51236 // bool Payee_eq(const struct LDKPayee *NONNULL_PTR a, const struct LDKPayee *NONNULL_PTR b);
51238 export function Payee_eq(a: bigint, b: bigint): boolean {
51239 if(!isWasmInitialized) {
51240 throw new Error("initializeWasm() must be awaited first!");
51242 const nativeResponseValue = wasm.TS_Payee_eq(a, b);
51243 return nativeResponseValue;
51245 // void RouteHint_free(struct LDKRouteHint this_obj);
51247 export function RouteHint_free(this_obj: bigint): void {
51248 if(!isWasmInitialized) {
51249 throw new Error("initializeWasm() must be awaited first!");
51251 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
51252 // debug statements here
51254 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
51256 export function RouteHint_get_a(this_ptr: bigint): number {
51257 if(!isWasmInitialized) {
51258 throw new Error("initializeWasm() must be awaited first!");
51260 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
51261 return nativeResponseValue;
51263 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
51265 export function RouteHint_set_a(this_ptr: bigint, val: number): void {
51266 if(!isWasmInitialized) {
51267 throw new Error("initializeWasm() must be awaited first!");
51269 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
51270 // debug statements here
51272 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
51274 export function RouteHint_new(a_arg: number): bigint {
51275 if(!isWasmInitialized) {
51276 throw new Error("initializeWasm() must be awaited first!");
51278 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
51279 return nativeResponseValue;
51281 // uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
51283 export function RouteHint_clone_ptr(arg: bigint): bigint {
51284 if(!isWasmInitialized) {
51285 throw new Error("initializeWasm() must be awaited first!");
51287 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
51288 return nativeResponseValue;
51290 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
51292 export function RouteHint_clone(orig: bigint): bigint {
51293 if(!isWasmInitialized) {
51294 throw new Error("initializeWasm() must be awaited first!");
51296 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
51297 return nativeResponseValue;
51299 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
51301 export function RouteHint_hash(o: bigint): bigint {
51302 if(!isWasmInitialized) {
51303 throw new Error("initializeWasm() must be awaited first!");
51305 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
51306 return nativeResponseValue;
51308 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
51310 export function RouteHint_eq(a: bigint, b: bigint): boolean {
51311 if(!isWasmInitialized) {
51312 throw new Error("initializeWasm() must be awaited first!");
51314 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
51315 return nativeResponseValue;
51317 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
51319 export function RouteHint_write(obj: bigint): number {
51320 if(!isWasmInitialized) {
51321 throw new Error("initializeWasm() must be awaited first!");
51323 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
51324 return nativeResponseValue;
51326 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
51328 export function RouteHint_read(ser: number): bigint {
51329 if(!isWasmInitialized) {
51330 throw new Error("initializeWasm() must be awaited first!");
51332 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
51333 return nativeResponseValue;
51335 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
51337 export function RouteHintHop_free(this_obj: bigint): void {
51338 if(!isWasmInitialized) {
51339 throw new Error("initializeWasm() must be awaited first!");
51341 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
51342 // debug statements here
51344 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
51346 export function RouteHintHop_get_src_node_id(this_ptr: bigint): number {
51347 if(!isWasmInitialized) {
51348 throw new Error("initializeWasm() must be awaited first!");
51350 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
51351 return nativeResponseValue;
51353 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
51355 export function RouteHintHop_set_src_node_id(this_ptr: bigint, val: number): void {
51356 if(!isWasmInitialized) {
51357 throw new Error("initializeWasm() must be awaited first!");
51359 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
51360 // debug statements here
51362 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
51364 export function RouteHintHop_get_short_channel_id(this_ptr: bigint): bigint {
51365 if(!isWasmInitialized) {
51366 throw new Error("initializeWasm() must be awaited first!");
51368 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
51369 return nativeResponseValue;
51371 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
51373 export function RouteHintHop_set_short_channel_id(this_ptr: bigint, val: bigint): void {
51374 if(!isWasmInitialized) {
51375 throw new Error("initializeWasm() must be awaited first!");
51377 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
51378 // debug statements here
51380 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
51382 export function RouteHintHop_get_fees(this_ptr: bigint): bigint {
51383 if(!isWasmInitialized) {
51384 throw new Error("initializeWasm() must be awaited first!");
51386 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
51387 return nativeResponseValue;
51389 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
51391 export function RouteHintHop_set_fees(this_ptr: bigint, val: bigint): void {
51392 if(!isWasmInitialized) {
51393 throw new Error("initializeWasm() must be awaited first!");
51395 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
51396 // debug statements here
51398 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
51400 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: bigint): number {
51401 if(!isWasmInitialized) {
51402 throw new Error("initializeWasm() must be awaited first!");
51404 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
51405 return nativeResponseValue;
51407 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
51409 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
51410 if(!isWasmInitialized) {
51411 throw new Error("initializeWasm() must be awaited first!");
51413 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
51414 // debug statements here
51416 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
51418 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: bigint): bigint {
51419 if(!isWasmInitialized) {
51420 throw new Error("initializeWasm() must be awaited first!");
51422 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
51423 return nativeResponseValue;
51425 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
51427 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
51428 if(!isWasmInitialized) {
51429 throw new Error("initializeWasm() must be awaited first!");
51431 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
51432 // debug statements here
51434 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
51436 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: bigint): bigint {
51437 if(!isWasmInitialized) {
51438 throw new Error("initializeWasm() must be awaited first!");
51440 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
51441 return nativeResponseValue;
51443 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
51445 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
51446 if(!isWasmInitialized) {
51447 throw new Error("initializeWasm() must be awaited first!");
51449 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
51450 // debug statements here
51452 // 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);
51454 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 {
51455 if(!isWasmInitialized) {
51456 throw new Error("initializeWasm() must be awaited first!");
51458 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);
51459 return nativeResponseValue;
51461 // uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
51463 export function RouteHintHop_clone_ptr(arg: bigint): bigint {
51464 if(!isWasmInitialized) {
51465 throw new Error("initializeWasm() must be awaited first!");
51467 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
51468 return nativeResponseValue;
51470 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
51472 export function RouteHintHop_clone(orig: bigint): bigint {
51473 if(!isWasmInitialized) {
51474 throw new Error("initializeWasm() must be awaited first!");
51476 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
51477 return nativeResponseValue;
51479 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
51481 export function RouteHintHop_hash(o: bigint): bigint {
51482 if(!isWasmInitialized) {
51483 throw new Error("initializeWasm() must be awaited first!");
51485 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
51486 return nativeResponseValue;
51488 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
51490 export function RouteHintHop_eq(a: bigint, b: bigint): boolean {
51491 if(!isWasmInitialized) {
51492 throw new Error("initializeWasm() must be awaited first!");
51494 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
51495 return nativeResponseValue;
51497 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
51499 export function RouteHintHop_write(obj: bigint): number {
51500 if(!isWasmInitialized) {
51501 throw new Error("initializeWasm() must be awaited first!");
51503 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
51504 return nativeResponseValue;
51506 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
51508 export function RouteHintHop_read(ser: number): bigint {
51509 if(!isWasmInitialized) {
51510 throw new Error("initializeWasm() must be awaited first!");
51512 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
51513 return nativeResponseValue;
51515 // void FirstHopCandidate_free(struct LDKFirstHopCandidate this_obj);
51517 export function FirstHopCandidate_free(this_obj: bigint): void {
51518 if(!isWasmInitialized) {
51519 throw new Error("initializeWasm() must be awaited first!");
51521 const nativeResponseValue = wasm.TS_FirstHopCandidate_free(this_obj);
51522 // debug statements here
51524 // uint64_t FirstHopCandidate_clone_ptr(LDKFirstHopCandidate *NONNULL_PTR arg);
51526 export function FirstHopCandidate_clone_ptr(arg: bigint): bigint {
51527 if(!isWasmInitialized) {
51528 throw new Error("initializeWasm() must be awaited first!");
51530 const nativeResponseValue = wasm.TS_FirstHopCandidate_clone_ptr(arg);
51531 return nativeResponseValue;
51533 // struct LDKFirstHopCandidate FirstHopCandidate_clone(const struct LDKFirstHopCandidate *NONNULL_PTR orig);
51535 export function FirstHopCandidate_clone(orig: bigint): bigint {
51536 if(!isWasmInitialized) {
51537 throw new Error("initializeWasm() must be awaited first!");
51539 const nativeResponseValue = wasm.TS_FirstHopCandidate_clone(orig);
51540 return nativeResponseValue;
51542 // void PublicHopCandidate_free(struct LDKPublicHopCandidate this_obj);
51544 export function PublicHopCandidate_free(this_obj: bigint): void {
51545 if(!isWasmInitialized) {
51546 throw new Error("initializeWasm() must be awaited first!");
51548 const nativeResponseValue = wasm.TS_PublicHopCandidate_free(this_obj);
51549 // debug statements here
51551 // uint64_t PublicHopCandidate_get_short_channel_id(const struct LDKPublicHopCandidate *NONNULL_PTR this_ptr);
51553 export function PublicHopCandidate_get_short_channel_id(this_ptr: bigint): bigint {
51554 if(!isWasmInitialized) {
51555 throw new Error("initializeWasm() must be awaited first!");
51557 const nativeResponseValue = wasm.TS_PublicHopCandidate_get_short_channel_id(this_ptr);
51558 return nativeResponseValue;
51560 // void PublicHopCandidate_set_short_channel_id(struct LDKPublicHopCandidate *NONNULL_PTR this_ptr, uint64_t val);
51562 export function PublicHopCandidate_set_short_channel_id(this_ptr: bigint, val: bigint): void {
51563 if(!isWasmInitialized) {
51564 throw new Error("initializeWasm() must be awaited first!");
51566 const nativeResponseValue = wasm.TS_PublicHopCandidate_set_short_channel_id(this_ptr, val);
51567 // debug statements here
51569 // uint64_t PublicHopCandidate_clone_ptr(LDKPublicHopCandidate *NONNULL_PTR arg);
51571 export function PublicHopCandidate_clone_ptr(arg: bigint): bigint {
51572 if(!isWasmInitialized) {
51573 throw new Error("initializeWasm() must be awaited first!");
51575 const nativeResponseValue = wasm.TS_PublicHopCandidate_clone_ptr(arg);
51576 return nativeResponseValue;
51578 // struct LDKPublicHopCandidate PublicHopCandidate_clone(const struct LDKPublicHopCandidate *NONNULL_PTR orig);
51580 export function PublicHopCandidate_clone(orig: bigint): bigint {
51581 if(!isWasmInitialized) {
51582 throw new Error("initializeWasm() must be awaited first!");
51584 const nativeResponseValue = wasm.TS_PublicHopCandidate_clone(orig);
51585 return nativeResponseValue;
51587 // void PrivateHopCandidate_free(struct LDKPrivateHopCandidate this_obj);
51589 export function PrivateHopCandidate_free(this_obj: bigint): void {
51590 if(!isWasmInitialized) {
51591 throw new Error("initializeWasm() must be awaited first!");
51593 const nativeResponseValue = wasm.TS_PrivateHopCandidate_free(this_obj);
51594 // debug statements here
51596 // uint64_t PrivateHopCandidate_clone_ptr(LDKPrivateHopCandidate *NONNULL_PTR arg);
51598 export function PrivateHopCandidate_clone_ptr(arg: bigint): bigint {
51599 if(!isWasmInitialized) {
51600 throw new Error("initializeWasm() must be awaited first!");
51602 const nativeResponseValue = wasm.TS_PrivateHopCandidate_clone_ptr(arg);
51603 return nativeResponseValue;
51605 // struct LDKPrivateHopCandidate PrivateHopCandidate_clone(const struct LDKPrivateHopCandidate *NONNULL_PTR orig);
51607 export function PrivateHopCandidate_clone(orig: bigint): bigint {
51608 if(!isWasmInitialized) {
51609 throw new Error("initializeWasm() must be awaited first!");
51611 const nativeResponseValue = wasm.TS_PrivateHopCandidate_clone(orig);
51612 return nativeResponseValue;
51614 // void BlindedPathCandidate_free(struct LDKBlindedPathCandidate this_obj);
51616 export function BlindedPathCandidate_free(this_obj: bigint): void {
51617 if(!isWasmInitialized) {
51618 throw new Error("initializeWasm() must be awaited first!");
51620 const nativeResponseValue = wasm.TS_BlindedPathCandidate_free(this_obj);
51621 // debug statements here
51623 // uint64_t BlindedPathCandidate_clone_ptr(LDKBlindedPathCandidate *NONNULL_PTR arg);
51625 export function BlindedPathCandidate_clone_ptr(arg: bigint): bigint {
51626 if(!isWasmInitialized) {
51627 throw new Error("initializeWasm() must be awaited first!");
51629 const nativeResponseValue = wasm.TS_BlindedPathCandidate_clone_ptr(arg);
51630 return nativeResponseValue;
51632 // struct LDKBlindedPathCandidate BlindedPathCandidate_clone(const struct LDKBlindedPathCandidate *NONNULL_PTR orig);
51634 export function BlindedPathCandidate_clone(orig: bigint): bigint {
51635 if(!isWasmInitialized) {
51636 throw new Error("initializeWasm() must be awaited first!");
51638 const nativeResponseValue = wasm.TS_BlindedPathCandidate_clone(orig);
51639 return nativeResponseValue;
51641 // void OneHopBlindedPathCandidate_free(struct LDKOneHopBlindedPathCandidate this_obj);
51643 export function OneHopBlindedPathCandidate_free(this_obj: bigint): void {
51644 if(!isWasmInitialized) {
51645 throw new Error("initializeWasm() must be awaited first!");
51647 const nativeResponseValue = wasm.TS_OneHopBlindedPathCandidate_free(this_obj);
51648 // debug statements here
51650 // uint64_t OneHopBlindedPathCandidate_clone_ptr(LDKOneHopBlindedPathCandidate *NONNULL_PTR arg);
51652 export function OneHopBlindedPathCandidate_clone_ptr(arg: bigint): bigint {
51653 if(!isWasmInitialized) {
51654 throw new Error("initializeWasm() must be awaited first!");
51656 const nativeResponseValue = wasm.TS_OneHopBlindedPathCandidate_clone_ptr(arg);
51657 return nativeResponseValue;
51659 // struct LDKOneHopBlindedPathCandidate OneHopBlindedPathCandidate_clone(const struct LDKOneHopBlindedPathCandidate *NONNULL_PTR orig);
51661 export function OneHopBlindedPathCandidate_clone(orig: bigint): bigint {
51662 if(!isWasmInitialized) {
51663 throw new Error("initializeWasm() must be awaited first!");
51665 const nativeResponseValue = wasm.TS_OneHopBlindedPathCandidate_clone(orig);
51666 return nativeResponseValue;
51668 // void CandidateRouteHop_free(struct LDKCandidateRouteHop this_ptr);
51670 export function CandidateRouteHop_free(this_ptr: bigint): void {
51671 if(!isWasmInitialized) {
51672 throw new Error("initializeWasm() must be awaited first!");
51674 const nativeResponseValue = wasm.TS_CandidateRouteHop_free(this_ptr);
51675 // debug statements here
51677 // uint64_t CandidateRouteHop_clone_ptr(LDKCandidateRouteHop *NONNULL_PTR arg);
51679 export function CandidateRouteHop_clone_ptr(arg: bigint): bigint {
51680 if(!isWasmInitialized) {
51681 throw new Error("initializeWasm() must be awaited first!");
51683 const nativeResponseValue = wasm.TS_CandidateRouteHop_clone_ptr(arg);
51684 return nativeResponseValue;
51686 // struct LDKCandidateRouteHop CandidateRouteHop_clone(const struct LDKCandidateRouteHop *NONNULL_PTR orig);
51688 export function CandidateRouteHop_clone(orig: bigint): bigint {
51689 if(!isWasmInitialized) {
51690 throw new Error("initializeWasm() must be awaited first!");
51692 const nativeResponseValue = wasm.TS_CandidateRouteHop_clone(orig);
51693 return nativeResponseValue;
51695 // struct LDKCandidateRouteHop CandidateRouteHop_first_hop(struct LDKFirstHopCandidate a);
51697 export function CandidateRouteHop_first_hop(a: bigint): bigint {
51698 if(!isWasmInitialized) {
51699 throw new Error("initializeWasm() must be awaited first!");
51701 const nativeResponseValue = wasm.TS_CandidateRouteHop_first_hop(a);
51702 return nativeResponseValue;
51704 // struct LDKCandidateRouteHop CandidateRouteHop_public_hop(struct LDKPublicHopCandidate a);
51706 export function CandidateRouteHop_public_hop(a: bigint): bigint {
51707 if(!isWasmInitialized) {
51708 throw new Error("initializeWasm() must be awaited first!");
51710 const nativeResponseValue = wasm.TS_CandidateRouteHop_public_hop(a);
51711 return nativeResponseValue;
51713 // struct LDKCandidateRouteHop CandidateRouteHop_private_hop(struct LDKPrivateHopCandidate a);
51715 export function CandidateRouteHop_private_hop(a: bigint): bigint {
51716 if(!isWasmInitialized) {
51717 throw new Error("initializeWasm() must be awaited first!");
51719 const nativeResponseValue = wasm.TS_CandidateRouteHop_private_hop(a);
51720 return nativeResponseValue;
51722 // struct LDKCandidateRouteHop CandidateRouteHop_blinded(struct LDKBlindedPathCandidate a);
51724 export function CandidateRouteHop_blinded(a: bigint): bigint {
51725 if(!isWasmInitialized) {
51726 throw new Error("initializeWasm() must be awaited first!");
51728 const nativeResponseValue = wasm.TS_CandidateRouteHop_blinded(a);
51729 return nativeResponseValue;
51731 // struct LDKCandidateRouteHop CandidateRouteHop_one_hop_blinded(struct LDKOneHopBlindedPathCandidate a);
51733 export function CandidateRouteHop_one_hop_blinded(a: bigint): bigint {
51734 if(!isWasmInitialized) {
51735 throw new Error("initializeWasm() must be awaited first!");
51737 const nativeResponseValue = wasm.TS_CandidateRouteHop_one_hop_blinded(a);
51738 return nativeResponseValue;
51740 // MUST_USE_RES struct LDKCOption_u64Z CandidateRouteHop_globally_unique_short_channel_id(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
51742 export function CandidateRouteHop_globally_unique_short_channel_id(this_arg: bigint): bigint {
51743 if(!isWasmInitialized) {
51744 throw new Error("initializeWasm() must be awaited first!");
51746 const nativeResponseValue = wasm.TS_CandidateRouteHop_globally_unique_short_channel_id(this_arg);
51747 return nativeResponseValue;
51749 // MUST_USE_RES uint32_t CandidateRouteHop_cltv_expiry_delta(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
51751 export function CandidateRouteHop_cltv_expiry_delta(this_arg: bigint): number {
51752 if(!isWasmInitialized) {
51753 throw new Error("initializeWasm() must be awaited first!");
51755 const nativeResponseValue = wasm.TS_CandidateRouteHop_cltv_expiry_delta(this_arg);
51756 return nativeResponseValue;
51758 // MUST_USE_RES uint64_t CandidateRouteHop_htlc_minimum_msat(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
51760 export function CandidateRouteHop_htlc_minimum_msat(this_arg: bigint): bigint {
51761 if(!isWasmInitialized) {
51762 throw new Error("initializeWasm() must be awaited first!");
51764 const nativeResponseValue = wasm.TS_CandidateRouteHop_htlc_minimum_msat(this_arg);
51765 return nativeResponseValue;
51767 // MUST_USE_RES struct LDKRoutingFees CandidateRouteHop_fees(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
51769 export function CandidateRouteHop_fees(this_arg: bigint): bigint {
51770 if(!isWasmInitialized) {
51771 throw new Error("initializeWasm() must be awaited first!");
51773 const nativeResponseValue = wasm.TS_CandidateRouteHop_fees(this_arg);
51774 return nativeResponseValue;
51776 // MUST_USE_RES struct LDKNodeId CandidateRouteHop_source(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
51778 export function CandidateRouteHop_source(this_arg: bigint): bigint {
51779 if(!isWasmInitialized) {
51780 throw new Error("initializeWasm() must be awaited first!");
51782 const nativeResponseValue = wasm.TS_CandidateRouteHop_source(this_arg);
51783 return nativeResponseValue;
51785 // MUST_USE_RES struct LDKNodeId CandidateRouteHop_target(const struct LDKCandidateRouteHop *NONNULL_PTR this_arg);
51787 export function CandidateRouteHop_target(this_arg: bigint): bigint {
51788 if(!isWasmInitialized) {
51789 throw new Error("initializeWasm() must be awaited first!");
51791 const nativeResponseValue = wasm.TS_CandidateRouteHop_target(this_arg);
51792 return nativeResponseValue;
51794 // 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]);
51796 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 {
51797 if(!isWasmInitialized) {
51798 throw new Error("initializeWasm() must be awaited first!");
51800 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, score_params, random_seed_bytes);
51801 return nativeResponseValue;
51803 // 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]);
51805 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 {
51806 if(!isWasmInitialized) {
51807 throw new Error("initializeWasm() must be awaited first!");
51809 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
51810 return nativeResponseValue;
51812 // void ScoreLookUp_free(struct LDKScoreLookUp this_ptr);
51814 export function ScoreLookUp_free(this_ptr: bigint): void {
51815 if(!isWasmInitialized) {
51816 throw new Error("initializeWasm() must be awaited first!");
51818 const nativeResponseValue = wasm.TS_ScoreLookUp_free(this_ptr);
51819 // debug statements here
51821 // void ScoreUpdate_free(struct LDKScoreUpdate this_ptr);
51823 export function ScoreUpdate_free(this_ptr: bigint): void {
51824 if(!isWasmInitialized) {
51825 throw new Error("initializeWasm() must be awaited first!");
51827 const nativeResponseValue = wasm.TS_ScoreUpdate_free(this_ptr);
51828 // debug statements here
51830 // void Score_free(struct LDKScore this_ptr);
51832 export function Score_free(this_ptr: bigint): void {
51833 if(!isWasmInitialized) {
51834 throw new Error("initializeWasm() must be awaited first!");
51836 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
51837 // debug statements here
51839 // void LockableScore_free(struct LDKLockableScore this_ptr);
51841 export function LockableScore_free(this_ptr: bigint): void {
51842 if(!isWasmInitialized) {
51843 throw new Error("initializeWasm() must be awaited first!");
51845 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
51846 // debug statements here
51848 // void WriteableScore_free(struct LDKWriteableScore this_ptr);
51850 export function WriteableScore_free(this_ptr: bigint): void {
51851 if(!isWasmInitialized) {
51852 throw new Error("initializeWasm() must be awaited first!");
51854 const nativeResponseValue = wasm.TS_WriteableScore_free(this_ptr);
51855 // debug statements here
51857 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
51859 export function MultiThreadedLockableScore_free(this_obj: bigint): void {
51860 if(!isWasmInitialized) {
51861 throw new Error("initializeWasm() must be awaited first!");
51863 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
51864 // debug statements here
51866 // struct LDKLockableScore MultiThreadedLockableScore_as_LockableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
51868 export function MultiThreadedLockableScore_as_LockableScore(this_arg: bigint): bigint {
51869 if(!isWasmInitialized) {
51870 throw new Error("initializeWasm() must be awaited first!");
51872 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_LockableScore(this_arg);
51873 return nativeResponseValue;
51875 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
51877 export function MultiThreadedLockableScore_write(obj: bigint): number {
51878 if(!isWasmInitialized) {
51879 throw new Error("initializeWasm() must be awaited first!");
51881 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
51882 return nativeResponseValue;
51884 // struct LDKWriteableScore MultiThreadedLockableScore_as_WriteableScore(const struct LDKMultiThreadedLockableScore *NONNULL_PTR this_arg);
51886 export function MultiThreadedLockableScore_as_WriteableScore(this_arg: bigint): bigint {
51887 if(!isWasmInitialized) {
51888 throw new Error("initializeWasm() must be awaited first!");
51890 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_as_WriteableScore(this_arg);
51891 return nativeResponseValue;
51893 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
51895 export function MultiThreadedLockableScore_new(score: bigint): bigint {
51896 if(!isWasmInitialized) {
51897 throw new Error("initializeWasm() must be awaited first!");
51899 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
51900 return nativeResponseValue;
51902 // void MultiThreadedScoreLockRead_free(struct LDKMultiThreadedScoreLockRead this_obj);
51904 export function MultiThreadedScoreLockRead_free(this_obj: bigint): void {
51905 if(!isWasmInitialized) {
51906 throw new Error("initializeWasm() must be awaited first!");
51908 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockRead_free(this_obj);
51909 // debug statements here
51911 // void MultiThreadedScoreLockWrite_free(struct LDKMultiThreadedScoreLockWrite this_obj);
51913 export function MultiThreadedScoreLockWrite_free(this_obj: bigint): void {
51914 if(!isWasmInitialized) {
51915 throw new Error("initializeWasm() must be awaited first!");
51917 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_free(this_obj);
51918 // debug statements here
51920 // struct LDKScoreLookUp MultiThreadedScoreLockRead_as_ScoreLookUp(const struct LDKMultiThreadedScoreLockRead *NONNULL_PTR this_arg);
51922 export function MultiThreadedScoreLockRead_as_ScoreLookUp(this_arg: bigint): bigint {
51923 if(!isWasmInitialized) {
51924 throw new Error("initializeWasm() must be awaited first!");
51926 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockRead_as_ScoreLookUp(this_arg);
51927 return nativeResponseValue;
51929 // struct LDKCVec_u8Z MultiThreadedScoreLockWrite_write(const struct LDKMultiThreadedScoreLockWrite *NONNULL_PTR obj);
51931 export function MultiThreadedScoreLockWrite_write(obj: bigint): number {
51932 if(!isWasmInitialized) {
51933 throw new Error("initializeWasm() must be awaited first!");
51935 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_write(obj);
51936 return nativeResponseValue;
51938 // struct LDKScoreUpdate MultiThreadedScoreLockWrite_as_ScoreUpdate(const struct LDKMultiThreadedScoreLockWrite *NONNULL_PTR this_arg);
51940 export function MultiThreadedScoreLockWrite_as_ScoreUpdate(this_arg: bigint): bigint {
51941 if(!isWasmInitialized) {
51942 throw new Error("initializeWasm() must be awaited first!");
51944 const nativeResponseValue = wasm.TS_MultiThreadedScoreLockWrite_as_ScoreUpdate(this_arg);
51945 return nativeResponseValue;
51947 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
51949 export function ChannelUsage_free(this_obj: bigint): void {
51950 if(!isWasmInitialized) {
51951 throw new Error("initializeWasm() must be awaited first!");
51953 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
51954 // debug statements here
51956 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
51958 export function ChannelUsage_get_amount_msat(this_ptr: bigint): bigint {
51959 if(!isWasmInitialized) {
51960 throw new Error("initializeWasm() must be awaited first!");
51962 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
51963 return nativeResponseValue;
51965 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
51967 export function ChannelUsage_set_amount_msat(this_ptr: bigint, val: bigint): void {
51968 if(!isWasmInitialized) {
51969 throw new Error("initializeWasm() must be awaited first!");
51971 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
51972 // debug statements here
51974 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
51976 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: bigint): bigint {
51977 if(!isWasmInitialized) {
51978 throw new Error("initializeWasm() must be awaited first!");
51980 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
51981 return nativeResponseValue;
51983 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
51985 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: bigint, val: bigint): void {
51986 if(!isWasmInitialized) {
51987 throw new Error("initializeWasm() must be awaited first!");
51989 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
51990 // debug statements here
51992 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
51994 export function ChannelUsage_get_effective_capacity(this_ptr: bigint): bigint {
51995 if(!isWasmInitialized) {
51996 throw new Error("initializeWasm() must be awaited first!");
51998 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
51999 return nativeResponseValue;
52001 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
52003 export function ChannelUsage_set_effective_capacity(this_ptr: bigint, val: bigint): void {
52004 if(!isWasmInitialized) {
52005 throw new Error("initializeWasm() must be awaited first!");
52007 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
52008 // debug statements here
52010 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
52012 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: bigint): bigint {
52013 if(!isWasmInitialized) {
52014 throw new Error("initializeWasm() must be awaited first!");
52016 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
52017 return nativeResponseValue;
52019 // uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
52021 export function ChannelUsage_clone_ptr(arg: bigint): bigint {
52022 if(!isWasmInitialized) {
52023 throw new Error("initializeWasm() must be awaited first!");
52025 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
52026 return nativeResponseValue;
52028 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
52030 export function ChannelUsage_clone(orig: bigint): bigint {
52031 if(!isWasmInitialized) {
52032 throw new Error("initializeWasm() must be awaited first!");
52034 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
52035 return nativeResponseValue;
52037 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
52039 export function FixedPenaltyScorer_free(this_obj: bigint): void {
52040 if(!isWasmInitialized) {
52041 throw new Error("initializeWasm() must be awaited first!");
52043 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
52044 // debug statements here
52046 // uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
52048 export function FixedPenaltyScorer_clone_ptr(arg: bigint): bigint {
52049 if(!isWasmInitialized) {
52050 throw new Error("initializeWasm() must be awaited first!");
52052 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
52053 return nativeResponseValue;
52055 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
52057 export function FixedPenaltyScorer_clone(orig: bigint): bigint {
52058 if(!isWasmInitialized) {
52059 throw new Error("initializeWasm() must be awaited first!");
52061 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
52062 return nativeResponseValue;
52064 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
52066 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): bigint {
52067 if(!isWasmInitialized) {
52068 throw new Error("initializeWasm() must be awaited first!");
52070 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
52071 return nativeResponseValue;
52073 // struct LDKScoreLookUp FixedPenaltyScorer_as_ScoreLookUp(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
52075 export function FixedPenaltyScorer_as_ScoreLookUp(this_arg: bigint): bigint {
52076 if(!isWasmInitialized) {
52077 throw new Error("initializeWasm() must be awaited first!");
52079 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_ScoreLookUp(this_arg);
52080 return nativeResponseValue;
52082 // struct LDKScoreUpdate FixedPenaltyScorer_as_ScoreUpdate(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
52084 export function FixedPenaltyScorer_as_ScoreUpdate(this_arg: bigint): bigint {
52085 if(!isWasmInitialized) {
52086 throw new Error("initializeWasm() must be awaited first!");
52088 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_ScoreUpdate(this_arg);
52089 return nativeResponseValue;
52091 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
52093 export function FixedPenaltyScorer_write(obj: bigint): number {
52094 if(!isWasmInitialized) {
52095 throw new Error("initializeWasm() must be awaited first!");
52097 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
52098 return nativeResponseValue;
52100 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
52102 export function FixedPenaltyScorer_read(ser: number, arg: bigint): bigint {
52103 if(!isWasmInitialized) {
52104 throw new Error("initializeWasm() must be awaited first!");
52106 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
52107 return nativeResponseValue;
52109 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
52111 export function ProbabilisticScorer_free(this_obj: bigint): void {
52112 if(!isWasmInitialized) {
52113 throw new Error("initializeWasm() must be awaited first!");
52115 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
52116 // debug statements here
52118 // void ProbabilisticScoringFeeParameters_free(struct LDKProbabilisticScoringFeeParameters this_obj);
52120 export function ProbabilisticScoringFeeParameters_free(this_obj: bigint): void {
52121 if(!isWasmInitialized) {
52122 throw new Error("initializeWasm() must be awaited first!");
52124 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_free(this_obj);
52125 // debug statements here
52127 // uint64_t ProbabilisticScoringFeeParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
52129 export function ProbabilisticScoringFeeParameters_get_base_penalty_msat(this_ptr: bigint): bigint {
52130 if(!isWasmInitialized) {
52131 throw new Error("initializeWasm() must be awaited first!");
52133 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_base_penalty_msat(this_ptr);
52134 return nativeResponseValue;
52136 // void ProbabilisticScoringFeeParameters_set_base_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
52138 export function ProbabilisticScoringFeeParameters_set_base_penalty_msat(this_ptr: bigint, val: bigint): void {
52139 if(!isWasmInitialized) {
52140 throw new Error("initializeWasm() must be awaited first!");
52142 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_base_penalty_msat(this_ptr, val);
52143 // debug statements here
52145 // uint64_t ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
52147 export function ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
52148 if(!isWasmInitialized) {
52149 throw new Error("initializeWasm() must be awaited first!");
52151 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
52152 return nativeResponseValue;
52154 // void ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
52156 export function ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
52157 if(!isWasmInitialized) {
52158 throw new Error("initializeWasm() must be awaited first!");
52160 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
52161 // debug statements here
52163 // uint64_t ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
52165 export function ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
52166 if(!isWasmInitialized) {
52167 throw new Error("initializeWasm() must be awaited first!");
52169 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
52170 return nativeResponseValue;
52172 // void ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
52174 export function ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
52175 if(!isWasmInitialized) {
52176 throw new Error("initializeWasm() must be awaited first!");
52178 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
52179 // debug statements here
52181 // uint64_t ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
52183 export function ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
52184 if(!isWasmInitialized) {
52185 throw new Error("initializeWasm() must be awaited first!");
52187 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
52188 return nativeResponseValue;
52190 // void ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
52192 export function ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
52193 if(!isWasmInitialized) {
52194 throw new Error("initializeWasm() must be awaited first!");
52196 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
52197 // debug statements here
52199 // uint64_t ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
52201 export function ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint): bigint {
52202 if(!isWasmInitialized) {
52203 throw new Error("initializeWasm() must be awaited first!");
52205 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr);
52206 return nativeResponseValue;
52208 // void ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
52210 export function ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr: bigint, val: bigint): void {
52211 if(!isWasmInitialized) {
52212 throw new Error("initializeWasm() must be awaited first!");
52214 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr, val);
52215 // debug statements here
52217 // uint64_t ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
52219 export function ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint): bigint {
52220 if(!isWasmInitialized) {
52221 throw new Error("initializeWasm() must be awaited first!");
52223 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr);
52224 return nativeResponseValue;
52226 // void ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
52228 export function ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: bigint, val: bigint): void {
52229 if(!isWasmInitialized) {
52230 throw new Error("initializeWasm() must be awaited first!");
52232 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
52233 // debug statements here
52235 // uint64_t ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
52237 export function ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(this_ptr: bigint): bigint {
52238 if(!isWasmInitialized) {
52239 throw new Error("initializeWasm() must be awaited first!");
52241 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(this_ptr);
52242 return nativeResponseValue;
52244 // void ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
52246 export function ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(this_ptr: bigint, val: bigint): void {
52247 if(!isWasmInitialized) {
52248 throw new Error("initializeWasm() must be awaited first!");
52250 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(this_ptr, val);
52251 // debug statements here
52253 // uint64_t ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
52255 export function ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(this_ptr: bigint): bigint {
52256 if(!isWasmInitialized) {
52257 throw new Error("initializeWasm() must be awaited first!");
52259 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(this_ptr);
52260 return nativeResponseValue;
52262 // void ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, uint64_t val);
52264 export function ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(this_ptr: bigint, val: bigint): void {
52265 if(!isWasmInitialized) {
52266 throw new Error("initializeWasm() must be awaited first!");
52268 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(this_ptr, val);
52269 // debug statements here
52271 // bool ProbabilisticScoringFeeParameters_get_linear_success_probability(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr);
52273 export function ProbabilisticScoringFeeParameters_get_linear_success_probability(this_ptr: bigint): boolean {
52274 if(!isWasmInitialized) {
52275 throw new Error("initializeWasm() must be awaited first!");
52277 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_get_linear_success_probability(this_ptr);
52278 return nativeResponseValue;
52280 // void ProbabilisticScoringFeeParameters_set_linear_success_probability(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_ptr, bool val);
52282 export function ProbabilisticScoringFeeParameters_set_linear_success_probability(this_ptr: bigint, val: boolean): void {
52283 if(!isWasmInitialized) {
52284 throw new Error("initializeWasm() must be awaited first!");
52286 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_linear_success_probability(this_ptr, val);
52287 // debug statements here
52289 // uint64_t ProbabilisticScoringFeeParameters_clone_ptr(LDKProbabilisticScoringFeeParameters *NONNULL_PTR arg);
52291 export function ProbabilisticScoringFeeParameters_clone_ptr(arg: bigint): bigint {
52292 if(!isWasmInitialized) {
52293 throw new Error("initializeWasm() must be awaited first!");
52295 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clone_ptr(arg);
52296 return nativeResponseValue;
52298 // struct LDKProbabilisticScoringFeeParameters ProbabilisticScoringFeeParameters_clone(const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR orig);
52300 export function ProbabilisticScoringFeeParameters_clone(orig: bigint): bigint {
52301 if(!isWasmInitialized) {
52302 throw new Error("initializeWasm() must be awaited first!");
52304 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clone(orig);
52305 return nativeResponseValue;
52307 // MUST_USE_RES struct LDKProbabilisticScoringFeeParameters ProbabilisticScoringFeeParameters_default(void);
52309 export function ProbabilisticScoringFeeParameters_default(): bigint {
52310 if(!isWasmInitialized) {
52311 throw new Error("initializeWasm() must be awaited first!");
52313 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_default();
52314 return nativeResponseValue;
52316 // void ProbabilisticScoringFeeParameters_add_banned(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
52318 export function ProbabilisticScoringFeeParameters_add_banned(this_arg: bigint, node_id: bigint): void {
52319 if(!isWasmInitialized) {
52320 throw new Error("initializeWasm() must be awaited first!");
52322 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_add_banned(this_arg, node_id);
52323 // debug statements here
52325 // void ProbabilisticScoringFeeParameters_add_banned_from_list(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
52327 export function ProbabilisticScoringFeeParameters_add_banned_from_list(this_arg: bigint, node_ids: number): void {
52328 if(!isWasmInitialized) {
52329 throw new Error("initializeWasm() must be awaited first!");
52331 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_add_banned_from_list(this_arg, node_ids);
52332 // debug statements here
52334 // void ProbabilisticScoringFeeParameters_remove_banned(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
52336 export function ProbabilisticScoringFeeParameters_remove_banned(this_arg: bigint, node_id: bigint): void {
52337 if(!isWasmInitialized) {
52338 throw new Error("initializeWasm() must be awaited first!");
52340 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_remove_banned(this_arg, node_id);
52341 // debug statements here
52343 // void ProbabilisticScoringFeeParameters_set_manual_penalty(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
52345 export function ProbabilisticScoringFeeParameters_set_manual_penalty(this_arg: bigint, node_id: bigint, penalty: bigint): void {
52346 if(!isWasmInitialized) {
52347 throw new Error("initializeWasm() must be awaited first!");
52349 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_set_manual_penalty(this_arg, node_id, penalty);
52350 // debug statements here
52352 // void ProbabilisticScoringFeeParameters_remove_manual_penalty(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
52354 export function ProbabilisticScoringFeeParameters_remove_manual_penalty(this_arg: bigint, node_id: bigint): void {
52355 if(!isWasmInitialized) {
52356 throw new Error("initializeWasm() must be awaited first!");
52358 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_remove_manual_penalty(this_arg, node_id);
52359 // debug statements here
52361 // void ProbabilisticScoringFeeParameters_clear_manual_penalties(struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR this_arg);
52363 export function ProbabilisticScoringFeeParameters_clear_manual_penalties(this_arg: bigint): void {
52364 if(!isWasmInitialized) {
52365 throw new Error("initializeWasm() must be awaited first!");
52367 const nativeResponseValue = wasm.TS_ProbabilisticScoringFeeParameters_clear_manual_penalties(this_arg);
52368 // debug statements here
52370 // void ProbabilisticScoringDecayParameters_free(struct LDKProbabilisticScoringDecayParameters this_obj);
52372 export function ProbabilisticScoringDecayParameters_free(this_obj: bigint): void {
52373 if(!isWasmInitialized) {
52374 throw new Error("initializeWasm() must be awaited first!");
52376 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_free(this_obj);
52377 // debug statements here
52379 // uint64_t ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr);
52381 export function ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(this_ptr: bigint): bigint {
52382 if(!isWasmInitialized) {
52383 throw new Error("initializeWasm() must be awaited first!");
52385 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(this_ptr);
52386 return nativeResponseValue;
52388 // void ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr, uint64_t val);
52390 export function ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(this_ptr: bigint, val: bigint): void {
52391 if(!isWasmInitialized) {
52392 throw new Error("initializeWasm() must be awaited first!");
52394 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(this_ptr, val);
52395 // debug statements here
52397 // uint64_t ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr);
52399 export function ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(this_ptr: bigint): bigint {
52400 if(!isWasmInitialized) {
52401 throw new Error("initializeWasm() must be awaited first!");
52403 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(this_ptr);
52404 return nativeResponseValue;
52406 // void ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR this_ptr, uint64_t val);
52408 export function ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(this_ptr: bigint, val: bigint): void {
52409 if(!isWasmInitialized) {
52410 throw new Error("initializeWasm() must be awaited first!");
52412 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(this_ptr, val);
52413 // debug statements here
52415 // MUST_USE_RES struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_new(uint64_t historical_no_updates_half_life_arg, uint64_t liquidity_offset_half_life_arg);
52417 export function ProbabilisticScoringDecayParameters_new(historical_no_updates_half_life_arg: bigint, liquidity_offset_half_life_arg: bigint): bigint {
52418 if(!isWasmInitialized) {
52419 throw new Error("initializeWasm() must be awaited first!");
52421 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_new(historical_no_updates_half_life_arg, liquidity_offset_half_life_arg);
52422 return nativeResponseValue;
52424 // uint64_t ProbabilisticScoringDecayParameters_clone_ptr(LDKProbabilisticScoringDecayParameters *NONNULL_PTR arg);
52426 export function ProbabilisticScoringDecayParameters_clone_ptr(arg: bigint): bigint {
52427 if(!isWasmInitialized) {
52428 throw new Error("initializeWasm() must be awaited first!");
52430 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_clone_ptr(arg);
52431 return nativeResponseValue;
52433 // struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_clone(const struct LDKProbabilisticScoringDecayParameters *NONNULL_PTR orig);
52435 export function ProbabilisticScoringDecayParameters_clone(orig: bigint): bigint {
52436 if(!isWasmInitialized) {
52437 throw new Error("initializeWasm() must be awaited first!");
52439 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_clone(orig);
52440 return nativeResponseValue;
52442 // MUST_USE_RES struct LDKProbabilisticScoringDecayParameters ProbabilisticScoringDecayParameters_default(void);
52444 export function ProbabilisticScoringDecayParameters_default(): bigint {
52445 if(!isWasmInitialized) {
52446 throw new Error("initializeWasm() must be awaited first!");
52448 const nativeResponseValue = wasm.TS_ProbabilisticScoringDecayParameters_default();
52449 return nativeResponseValue;
52451 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringDecayParameters decay_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
52453 export function ProbabilisticScorer_new(decay_params: bigint, network_graph: bigint, logger: bigint): bigint {
52454 if(!isWasmInitialized) {
52455 throw new Error("initializeWasm() must be awaited first!");
52457 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(decay_params, network_graph, logger);
52458 return nativeResponseValue;
52460 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
52462 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: bigint): void {
52463 if(!isWasmInitialized) {
52464 throw new Error("initializeWasm() must be awaited first!");
52466 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
52467 // debug statements here
52469 // 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);
52471 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: bigint, scid: bigint, target: bigint): bigint {
52472 if(!isWasmInitialized) {
52473 throw new Error("initializeWasm() must be awaited first!");
52475 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
52476 return nativeResponseValue;
52478 // 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);
52480 export function ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg: bigint, scid: bigint, target: bigint): bigint {
52481 if(!isWasmInitialized) {
52482 throw new Error("initializeWasm() must be awaited first!");
52484 const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(this_arg, scid, target);
52485 return nativeResponseValue;
52487 // 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);
52489 export function ProbabilisticScorer_historical_estimated_payment_success_probability(this_arg: bigint, scid: bigint, target: bigint, amount_msat: bigint, params: bigint): bigint {
52490 if(!isWasmInitialized) {
52491 throw new Error("initializeWasm() must be awaited first!");
52493 const nativeResponseValue = wasm.TS_ProbabilisticScorer_historical_estimated_payment_success_probability(this_arg, scid, target, amount_msat, params);
52494 return nativeResponseValue;
52496 // struct LDKScoreLookUp ProbabilisticScorer_as_ScoreLookUp(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
52498 export function ProbabilisticScorer_as_ScoreLookUp(this_arg: bigint): bigint {
52499 if(!isWasmInitialized) {
52500 throw new Error("initializeWasm() must be awaited first!");
52502 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_ScoreLookUp(this_arg);
52503 return nativeResponseValue;
52505 // struct LDKScoreUpdate ProbabilisticScorer_as_ScoreUpdate(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
52507 export function ProbabilisticScorer_as_ScoreUpdate(this_arg: bigint): bigint {
52508 if(!isWasmInitialized) {
52509 throw new Error("initializeWasm() must be awaited first!");
52511 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_ScoreUpdate(this_arg);
52512 return nativeResponseValue;
52514 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
52516 export function ProbabilisticScorer_as_Score(this_arg: bigint): bigint {
52517 if(!isWasmInitialized) {
52518 throw new Error("initializeWasm() must be awaited first!");
52520 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
52521 return nativeResponseValue;
52523 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
52525 export function ProbabilisticScorer_write(obj: bigint): number {
52526 if(!isWasmInitialized) {
52527 throw new Error("initializeWasm() must be awaited first!");
52529 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
52530 return nativeResponseValue;
52532 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringDecayParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
52534 export function ProbabilisticScorer_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint): bigint {
52535 if(!isWasmInitialized) {
52536 throw new Error("initializeWasm() must be awaited first!");
52538 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
52539 return nativeResponseValue;
52541 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
52543 export function DelayedPaymentOutputDescriptor_free(this_obj: bigint): void {
52544 if(!isWasmInitialized) {
52545 throw new Error("initializeWasm() must be awaited first!");
52547 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
52548 // debug statements here
52550 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
52552 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
52553 if(!isWasmInitialized) {
52554 throw new Error("initializeWasm() must be awaited first!");
52556 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
52557 return nativeResponseValue;
52559 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
52561 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
52562 if(!isWasmInitialized) {
52563 throw new Error("initializeWasm() must be awaited first!");
52565 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
52566 // debug statements here
52568 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
52570 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: bigint): number {
52571 if(!isWasmInitialized) {
52572 throw new Error("initializeWasm() must be awaited first!");
52574 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
52575 return nativeResponseValue;
52577 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
52579 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
52580 if(!isWasmInitialized) {
52581 throw new Error("initializeWasm() must be awaited first!");
52583 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
52584 // debug statements here
52586 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
52588 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: bigint): number {
52589 if(!isWasmInitialized) {
52590 throw new Error("initializeWasm() must be awaited first!");
52592 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
52593 return nativeResponseValue;
52595 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
52597 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: bigint, val: number): void {
52598 if(!isWasmInitialized) {
52599 throw new Error("initializeWasm() must be awaited first!");
52601 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
52602 // debug statements here
52604 // struct LDKTxOut DelayedPaymentOutputDescriptor_get_output(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
52606 export function DelayedPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
52607 if(!isWasmInitialized) {
52608 throw new Error("initializeWasm() must be awaited first!");
52610 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_output(this_ptr);
52611 return nativeResponseValue;
52613 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
52615 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
52616 if(!isWasmInitialized) {
52617 throw new Error("initializeWasm() must be awaited first!");
52619 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
52620 // debug statements here
52622 // struct LDKRevocationKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
52624 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: bigint): bigint {
52625 if(!isWasmInitialized) {
52626 throw new Error("initializeWasm() must be awaited first!");
52628 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
52629 return nativeResponseValue;
52631 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKRevocationKey val);
52633 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: bigint, val: bigint): void {
52634 if(!isWasmInitialized) {
52635 throw new Error("initializeWasm() must be awaited first!");
52637 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
52638 // debug statements here
52640 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
52642 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
52643 if(!isWasmInitialized) {
52644 throw new Error("initializeWasm() must be awaited first!");
52646 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
52647 return nativeResponseValue;
52649 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
52651 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
52652 if(!isWasmInitialized) {
52653 throw new Error("initializeWasm() must be awaited first!");
52655 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
52656 // debug statements here
52658 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
52660 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
52661 if(!isWasmInitialized) {
52662 throw new Error("initializeWasm() must be awaited first!");
52664 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
52665 return nativeResponseValue;
52667 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
52669 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
52670 if(!isWasmInitialized) {
52671 throw new Error("initializeWasm() must be awaited first!");
52673 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
52674 // debug statements here
52676 // MUST_USE_RES struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_new(struct LDKOutPoint outpoint_arg, struct LDKPublicKey per_commitment_point_arg, uint16_t to_self_delay_arg, struct LDKTxOut output_arg, struct LDKRevocationKey revocation_pubkey_arg, struct LDKThirtyTwoBytes channel_keys_id_arg, uint64_t channel_value_satoshis_arg);
52678 export function DelayedPaymentOutputDescriptor_new(outpoint_arg: bigint, per_commitment_point_arg: number, to_self_delay_arg: number, output_arg: bigint, revocation_pubkey_arg: bigint, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): bigint {
52679 if(!isWasmInitialized) {
52680 throw new Error("initializeWasm() must be awaited first!");
52682 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);
52683 return nativeResponseValue;
52685 // uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
52687 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
52688 if(!isWasmInitialized) {
52689 throw new Error("initializeWasm() must be awaited first!");
52691 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
52692 return nativeResponseValue;
52694 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
52696 export function DelayedPaymentOutputDescriptor_clone(orig: bigint): bigint {
52697 if(!isWasmInitialized) {
52698 throw new Error("initializeWasm() must be awaited first!");
52700 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
52701 return nativeResponseValue;
52703 // uint64_t DelayedPaymentOutputDescriptor_hash(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR o);
52705 export function DelayedPaymentOutputDescriptor_hash(o: bigint): bigint {
52706 if(!isWasmInitialized) {
52707 throw new Error("initializeWasm() must be awaited first!");
52709 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_hash(o);
52710 return nativeResponseValue;
52712 // bool DelayedPaymentOutputDescriptor_eq(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR b);
52714 export function DelayedPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
52715 if(!isWasmInitialized) {
52716 throw new Error("initializeWasm() must be awaited first!");
52718 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_eq(a, b);
52719 return nativeResponseValue;
52721 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
52723 export function DelayedPaymentOutputDescriptor_write(obj: bigint): number {
52724 if(!isWasmInitialized) {
52725 throw new Error("initializeWasm() must be awaited first!");
52727 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
52728 return nativeResponseValue;
52730 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
52732 export function DelayedPaymentOutputDescriptor_read(ser: number): bigint {
52733 if(!isWasmInitialized) {
52734 throw new Error("initializeWasm() must be awaited first!");
52736 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
52737 return nativeResponseValue;
52739 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
52741 export function StaticPaymentOutputDescriptor_free(this_obj: bigint): void {
52742 if(!isWasmInitialized) {
52743 throw new Error("initializeWasm() must be awaited first!");
52745 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
52746 // debug statements here
52748 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
52750 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: bigint): bigint {
52751 if(!isWasmInitialized) {
52752 throw new Error("initializeWasm() must be awaited first!");
52754 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
52755 return nativeResponseValue;
52757 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
52759 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
52760 if(!isWasmInitialized) {
52761 throw new Error("initializeWasm() must be awaited first!");
52763 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
52764 // debug statements here
52766 // struct LDKTxOut StaticPaymentOutputDescriptor_get_output(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
52768 export function StaticPaymentOutputDescriptor_get_output(this_ptr: bigint): bigint {
52769 if(!isWasmInitialized) {
52770 throw new Error("initializeWasm() must be awaited first!");
52772 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_output(this_ptr);
52773 return nativeResponseValue;
52775 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
52777 export function StaticPaymentOutputDescriptor_set_output(this_ptr: bigint, val: bigint): void {
52778 if(!isWasmInitialized) {
52779 throw new Error("initializeWasm() must be awaited first!");
52781 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
52782 // debug statements here
52784 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
52786 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: bigint): number {
52787 if(!isWasmInitialized) {
52788 throw new Error("initializeWasm() must be awaited first!");
52790 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
52791 return nativeResponseValue;
52793 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
52795 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: bigint, val: number): void {
52796 if(!isWasmInitialized) {
52797 throw new Error("initializeWasm() must be awaited first!");
52799 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
52800 // debug statements here
52802 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
52804 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: bigint): bigint {
52805 if(!isWasmInitialized) {
52806 throw new Error("initializeWasm() must be awaited first!");
52808 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
52809 return nativeResponseValue;
52811 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
52813 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
52814 if(!isWasmInitialized) {
52815 throw new Error("initializeWasm() must be awaited first!");
52817 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
52818 // debug statements here
52820 // struct LDKChannelTransactionParameters StaticPaymentOutputDescriptor_get_channel_transaction_parameters(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
52822 export function StaticPaymentOutputDescriptor_get_channel_transaction_parameters(this_ptr: bigint): bigint {
52823 if(!isWasmInitialized) {
52824 throw new Error("initializeWasm() must be awaited first!");
52826 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_transaction_parameters(this_ptr);
52827 return nativeResponseValue;
52829 // void StaticPaymentOutputDescriptor_set_channel_transaction_parameters(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKChannelTransactionParameters val);
52831 export function StaticPaymentOutputDescriptor_set_channel_transaction_parameters(this_ptr: bigint, val: bigint): void {
52832 if(!isWasmInitialized) {
52833 throw new Error("initializeWasm() must be awaited first!");
52835 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_transaction_parameters(this_ptr, val);
52836 // debug statements here
52838 // 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);
52840 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 {
52841 if(!isWasmInitialized) {
52842 throw new Error("initializeWasm() must be awaited first!");
52844 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg, channel_transaction_parameters_arg);
52845 return nativeResponseValue;
52847 // uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
52849 export function StaticPaymentOutputDescriptor_clone_ptr(arg: bigint): bigint {
52850 if(!isWasmInitialized) {
52851 throw new Error("initializeWasm() must be awaited first!");
52853 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
52854 return nativeResponseValue;
52856 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
52858 export function StaticPaymentOutputDescriptor_clone(orig: bigint): bigint {
52859 if(!isWasmInitialized) {
52860 throw new Error("initializeWasm() must be awaited first!");
52862 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
52863 return nativeResponseValue;
52865 // uint64_t StaticPaymentOutputDescriptor_hash(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR o);
52867 export function StaticPaymentOutputDescriptor_hash(o: bigint): bigint {
52868 if(!isWasmInitialized) {
52869 throw new Error("initializeWasm() must be awaited first!");
52871 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_hash(o);
52872 return nativeResponseValue;
52874 // bool StaticPaymentOutputDescriptor_eq(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR a, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR b);
52876 export function StaticPaymentOutputDescriptor_eq(a: bigint, b: bigint): boolean {
52877 if(!isWasmInitialized) {
52878 throw new Error("initializeWasm() must be awaited first!");
52880 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_eq(a, b);
52881 return nativeResponseValue;
52883 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ StaticPaymentOutputDescriptor_witness_script(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_arg);
52885 export function StaticPaymentOutputDescriptor_witness_script(this_arg: bigint): bigint {
52886 if(!isWasmInitialized) {
52887 throw new Error("initializeWasm() must be awaited first!");
52889 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_witness_script(this_arg);
52890 return nativeResponseValue;
52892 // MUST_USE_RES uint64_t StaticPaymentOutputDescriptor_max_witness_length(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_arg);
52894 export function StaticPaymentOutputDescriptor_max_witness_length(this_arg: bigint): bigint {
52895 if(!isWasmInitialized) {
52896 throw new Error("initializeWasm() must be awaited first!");
52898 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_max_witness_length(this_arg);
52899 return nativeResponseValue;
52901 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
52903 export function StaticPaymentOutputDescriptor_write(obj: bigint): number {
52904 if(!isWasmInitialized) {
52905 throw new Error("initializeWasm() must be awaited first!");
52907 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
52908 return nativeResponseValue;
52910 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
52912 export function StaticPaymentOutputDescriptor_read(ser: number): bigint {
52913 if(!isWasmInitialized) {
52914 throw new Error("initializeWasm() must be awaited first!");
52916 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
52917 return nativeResponseValue;
52919 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
52921 export function SpendableOutputDescriptor_free(this_ptr: bigint): void {
52922 if(!isWasmInitialized) {
52923 throw new Error("initializeWasm() must be awaited first!");
52925 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
52926 // debug statements here
52928 // uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
52930 export function SpendableOutputDescriptor_clone_ptr(arg: bigint): bigint {
52931 if(!isWasmInitialized) {
52932 throw new Error("initializeWasm() must be awaited first!");
52934 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
52935 return nativeResponseValue;
52937 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
52939 export function SpendableOutputDescriptor_clone(orig: bigint): bigint {
52940 if(!isWasmInitialized) {
52941 throw new Error("initializeWasm() must be awaited first!");
52943 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
52944 return nativeResponseValue;
52946 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output, struct LDKThirtyTwoBytes channel_keys_id);
52948 export function SpendableOutputDescriptor_static_output(outpoint: bigint, output: bigint, channel_keys_id: number): bigint {
52949 if(!isWasmInitialized) {
52950 throw new Error("initializeWasm() must be awaited first!");
52952 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output, channel_keys_id);
52953 return nativeResponseValue;
52955 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
52957 export function SpendableOutputDescriptor_delayed_payment_output(a: bigint): bigint {
52958 if(!isWasmInitialized) {
52959 throw new Error("initializeWasm() must be awaited first!");
52961 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
52962 return nativeResponseValue;
52964 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
52966 export function SpendableOutputDescriptor_static_payment_output(a: bigint): bigint {
52967 if(!isWasmInitialized) {
52968 throw new Error("initializeWasm() must be awaited first!");
52970 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
52971 return nativeResponseValue;
52973 // uint64_t SpendableOutputDescriptor_hash(const struct LDKSpendableOutputDescriptor *NONNULL_PTR o);
52975 export function SpendableOutputDescriptor_hash(o: bigint): bigint {
52976 if(!isWasmInitialized) {
52977 throw new Error("initializeWasm() must be awaited first!");
52979 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_hash(o);
52980 return nativeResponseValue;
52982 // bool SpendableOutputDescriptor_eq(const struct LDKSpendableOutputDescriptor *NONNULL_PTR a, const struct LDKSpendableOutputDescriptor *NONNULL_PTR b);
52984 export function SpendableOutputDescriptor_eq(a: bigint, b: bigint): boolean {
52985 if(!isWasmInitialized) {
52986 throw new Error("initializeWasm() must be awaited first!");
52988 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_eq(a, b);
52989 return nativeResponseValue;
52991 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
52993 export function SpendableOutputDescriptor_write(obj: bigint): number {
52994 if(!isWasmInitialized) {
52995 throw new Error("initializeWasm() must be awaited first!");
52997 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
52998 return nativeResponseValue;
53000 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
53002 export function SpendableOutputDescriptor_read(ser: number): bigint {
53003 if(!isWasmInitialized) {
53004 throw new Error("initializeWasm() must be awaited first!");
53006 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
53007 return nativeResponseValue;
53009 // MUST_USE_RES struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ SpendableOutputDescriptor_create_spendable_outputs_psbt(struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_u32Z locktime);
53011 export function SpendableOutputDescriptor_create_spendable_outputs_psbt(descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number, locktime: bigint): bigint {
53012 if(!isWasmInitialized) {
53013 throw new Error("initializeWasm() must be awaited first!");
53015 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_create_spendable_outputs_psbt(descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
53016 return nativeResponseValue;
53018 // void ChannelDerivationParameters_free(struct LDKChannelDerivationParameters this_obj);
53020 export function ChannelDerivationParameters_free(this_obj: bigint): void {
53021 if(!isWasmInitialized) {
53022 throw new Error("initializeWasm() must be awaited first!");
53024 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_free(this_obj);
53025 // debug statements here
53027 // uint64_t ChannelDerivationParameters_get_value_satoshis(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
53029 export function ChannelDerivationParameters_get_value_satoshis(this_ptr: bigint): bigint {
53030 if(!isWasmInitialized) {
53031 throw new Error("initializeWasm() must be awaited first!");
53033 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_value_satoshis(this_ptr);
53034 return nativeResponseValue;
53036 // void ChannelDerivationParameters_set_value_satoshis(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, uint64_t val);
53038 export function ChannelDerivationParameters_set_value_satoshis(this_ptr: bigint, val: bigint): void {
53039 if(!isWasmInitialized) {
53040 throw new Error("initializeWasm() must be awaited first!");
53042 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_value_satoshis(this_ptr, val);
53043 // debug statements here
53045 // const uint8_t (*ChannelDerivationParameters_get_keys_id(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr))[32];
53047 export function ChannelDerivationParameters_get_keys_id(this_ptr: bigint): number {
53048 if(!isWasmInitialized) {
53049 throw new Error("initializeWasm() must be awaited first!");
53051 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_keys_id(this_ptr);
53052 return nativeResponseValue;
53054 // void ChannelDerivationParameters_set_keys_id(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
53056 export function ChannelDerivationParameters_set_keys_id(this_ptr: bigint, val: number): void {
53057 if(!isWasmInitialized) {
53058 throw new Error("initializeWasm() must be awaited first!");
53060 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_keys_id(this_ptr, val);
53061 // debug statements here
53063 // struct LDKChannelTransactionParameters ChannelDerivationParameters_get_transaction_parameters(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
53065 export function ChannelDerivationParameters_get_transaction_parameters(this_ptr: bigint): bigint {
53066 if(!isWasmInitialized) {
53067 throw new Error("initializeWasm() must be awaited first!");
53069 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_transaction_parameters(this_ptr);
53070 return nativeResponseValue;
53072 // void ChannelDerivationParameters_set_transaction_parameters(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKChannelTransactionParameters val);
53074 export function ChannelDerivationParameters_set_transaction_parameters(this_ptr: bigint, val: bigint): void {
53075 if(!isWasmInitialized) {
53076 throw new Error("initializeWasm() must be awaited first!");
53078 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_transaction_parameters(this_ptr, val);
53079 // debug statements here
53081 // MUST_USE_RES struct LDKChannelDerivationParameters ChannelDerivationParameters_new(uint64_t value_satoshis_arg, struct LDKThirtyTwoBytes keys_id_arg, struct LDKChannelTransactionParameters transaction_parameters_arg);
53083 export function ChannelDerivationParameters_new(value_satoshis_arg: bigint, keys_id_arg: number, transaction_parameters_arg: bigint): bigint {
53084 if(!isWasmInitialized) {
53085 throw new Error("initializeWasm() must be awaited first!");
53087 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_new(value_satoshis_arg, keys_id_arg, transaction_parameters_arg);
53088 return nativeResponseValue;
53090 // uint64_t ChannelDerivationParameters_clone_ptr(LDKChannelDerivationParameters *NONNULL_PTR arg);
53092 export function ChannelDerivationParameters_clone_ptr(arg: bigint): bigint {
53093 if(!isWasmInitialized) {
53094 throw new Error("initializeWasm() must be awaited first!");
53096 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone_ptr(arg);
53097 return nativeResponseValue;
53099 // struct LDKChannelDerivationParameters ChannelDerivationParameters_clone(const struct LDKChannelDerivationParameters *NONNULL_PTR orig);
53101 export function ChannelDerivationParameters_clone(orig: bigint): bigint {
53102 if(!isWasmInitialized) {
53103 throw new Error("initializeWasm() must be awaited first!");
53105 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone(orig);
53106 return nativeResponseValue;
53108 // bool ChannelDerivationParameters_eq(const struct LDKChannelDerivationParameters *NONNULL_PTR a, const struct LDKChannelDerivationParameters *NONNULL_PTR b);
53110 export function ChannelDerivationParameters_eq(a: bigint, b: bigint): boolean {
53111 if(!isWasmInitialized) {
53112 throw new Error("initializeWasm() must be awaited first!");
53114 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_eq(a, b);
53115 return nativeResponseValue;
53117 // struct LDKCVec_u8Z ChannelDerivationParameters_write(const struct LDKChannelDerivationParameters *NONNULL_PTR obj);
53119 export function ChannelDerivationParameters_write(obj: bigint): number {
53120 if(!isWasmInitialized) {
53121 throw new Error("initializeWasm() must be awaited first!");
53123 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_write(obj);
53124 return nativeResponseValue;
53126 // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ ChannelDerivationParameters_read(struct LDKu8slice ser);
53128 export function ChannelDerivationParameters_read(ser: number): bigint {
53129 if(!isWasmInitialized) {
53130 throw new Error("initializeWasm() must be awaited first!");
53132 const nativeResponseValue = wasm.TS_ChannelDerivationParameters_read(ser);
53133 return nativeResponseValue;
53135 // void HTLCDescriptor_free(struct LDKHTLCDescriptor this_obj);
53137 export function HTLCDescriptor_free(this_obj: bigint): void {
53138 if(!isWasmInitialized) {
53139 throw new Error("initializeWasm() must be awaited first!");
53141 const nativeResponseValue = wasm.TS_HTLCDescriptor_free(this_obj);
53142 // debug statements here
53144 // struct LDKChannelDerivationParameters HTLCDescriptor_get_channel_derivation_parameters(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
53146 export function HTLCDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
53147 if(!isWasmInitialized) {
53148 throw new Error("initializeWasm() must be awaited first!");
53150 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_channel_derivation_parameters(this_ptr);
53151 return nativeResponseValue;
53153 // void HTLCDescriptor_set_channel_derivation_parameters(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
53155 export function HTLCDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
53156 if(!isWasmInitialized) {
53157 throw new Error("initializeWasm() must be awaited first!");
53159 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_channel_derivation_parameters(this_ptr, val);
53160 // debug statements here
53162 // uint64_t HTLCDescriptor_get_per_commitment_number(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
53164 export function HTLCDescriptor_get_per_commitment_number(this_ptr: bigint): bigint {
53165 if(!isWasmInitialized) {
53166 throw new Error("initializeWasm() must be awaited first!");
53168 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_number(this_ptr);
53169 return nativeResponseValue;
53171 // void HTLCDescriptor_set_per_commitment_number(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, uint64_t val);
53173 export function HTLCDescriptor_set_per_commitment_number(this_ptr: bigint, val: bigint): void {
53174 if(!isWasmInitialized) {
53175 throw new Error("initializeWasm() must be awaited first!");
53177 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_number(this_ptr, val);
53178 // debug statements here
53180 // struct LDKPublicKey HTLCDescriptor_get_per_commitment_point(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
53182 export function HTLCDescriptor_get_per_commitment_point(this_ptr: bigint): number {
53183 if(!isWasmInitialized) {
53184 throw new Error("initializeWasm() must be awaited first!");
53186 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_point(this_ptr);
53187 return nativeResponseValue;
53189 // void HTLCDescriptor_set_per_commitment_point(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
53191 export function HTLCDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
53192 if(!isWasmInitialized) {
53193 throw new Error("initializeWasm() must be awaited first!");
53195 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_point(this_ptr, val);
53196 // debug statements here
53198 // uint32_t HTLCDescriptor_get_feerate_per_kw(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
53200 export function HTLCDescriptor_get_feerate_per_kw(this_ptr: bigint): number {
53201 if(!isWasmInitialized) {
53202 throw new Error("initializeWasm() must be awaited first!");
53204 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_feerate_per_kw(this_ptr);
53205 return nativeResponseValue;
53207 // void HTLCDescriptor_set_feerate_per_kw(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, uint32_t val);
53209 export function HTLCDescriptor_set_feerate_per_kw(this_ptr: bigint, val: number): void {
53210 if(!isWasmInitialized) {
53211 throw new Error("initializeWasm() must be awaited first!");
53213 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_feerate_per_kw(this_ptr, val);
53214 // debug statements here
53216 // struct LDKHTLCOutputInCommitment HTLCDescriptor_get_htlc(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
53218 export function HTLCDescriptor_get_htlc(this_ptr: bigint): bigint {
53219 if(!isWasmInitialized) {
53220 throw new Error("initializeWasm() must be awaited first!");
53222 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_htlc(this_ptr);
53223 return nativeResponseValue;
53225 // void HTLCDescriptor_set_htlc(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKHTLCOutputInCommitment val);
53227 export function HTLCDescriptor_set_htlc(this_ptr: bigint, val: bigint): void {
53228 if(!isWasmInitialized) {
53229 throw new Error("initializeWasm() must be awaited first!");
53231 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_htlc(this_ptr, val);
53232 // debug statements here
53234 // struct LDKCOption_ThirtyTwoBytesZ HTLCDescriptor_get_preimage(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
53236 export function HTLCDescriptor_get_preimage(this_ptr: bigint): bigint {
53237 if(!isWasmInitialized) {
53238 throw new Error("initializeWasm() must be awaited first!");
53240 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_preimage(this_ptr);
53241 return nativeResponseValue;
53243 // void HTLCDescriptor_set_preimage(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
53245 export function HTLCDescriptor_set_preimage(this_ptr: bigint, val: bigint): void {
53246 if(!isWasmInitialized) {
53247 throw new Error("initializeWasm() must be awaited first!");
53249 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_preimage(this_ptr, val);
53250 // debug statements here
53252 // struct LDKECDSASignature HTLCDescriptor_get_counterparty_sig(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
53254 export function HTLCDescriptor_get_counterparty_sig(this_ptr: bigint): number {
53255 if(!isWasmInitialized) {
53256 throw new Error("initializeWasm() must be awaited first!");
53258 const nativeResponseValue = wasm.TS_HTLCDescriptor_get_counterparty_sig(this_ptr);
53259 return nativeResponseValue;
53261 // void HTLCDescriptor_set_counterparty_sig(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
53263 export function HTLCDescriptor_set_counterparty_sig(this_ptr: bigint, val: number): void {
53264 if(!isWasmInitialized) {
53265 throw new Error("initializeWasm() must be awaited first!");
53267 const nativeResponseValue = wasm.TS_HTLCDescriptor_set_counterparty_sig(this_ptr, val);
53268 // debug statements here
53270 // uint64_t HTLCDescriptor_clone_ptr(LDKHTLCDescriptor *NONNULL_PTR arg);
53272 export function HTLCDescriptor_clone_ptr(arg: bigint): bigint {
53273 if(!isWasmInitialized) {
53274 throw new Error("initializeWasm() must be awaited first!");
53276 const nativeResponseValue = wasm.TS_HTLCDescriptor_clone_ptr(arg);
53277 return nativeResponseValue;
53279 // struct LDKHTLCDescriptor HTLCDescriptor_clone(const struct LDKHTLCDescriptor *NONNULL_PTR orig);
53281 export function HTLCDescriptor_clone(orig: bigint): bigint {
53282 if(!isWasmInitialized) {
53283 throw new Error("initializeWasm() must be awaited first!");
53285 const nativeResponseValue = wasm.TS_HTLCDescriptor_clone(orig);
53286 return nativeResponseValue;
53288 // bool HTLCDescriptor_eq(const struct LDKHTLCDescriptor *NONNULL_PTR a, const struct LDKHTLCDescriptor *NONNULL_PTR b);
53290 export function HTLCDescriptor_eq(a: bigint, b: bigint): boolean {
53291 if(!isWasmInitialized) {
53292 throw new Error("initializeWasm() must be awaited first!");
53294 const nativeResponseValue = wasm.TS_HTLCDescriptor_eq(a, b);
53295 return nativeResponseValue;
53297 // struct LDKCVec_u8Z HTLCDescriptor_write(const struct LDKHTLCDescriptor *NONNULL_PTR obj);
53299 export function HTLCDescriptor_write(obj: bigint): number {
53300 if(!isWasmInitialized) {
53301 throw new Error("initializeWasm() must be awaited first!");
53303 const nativeResponseValue = wasm.TS_HTLCDescriptor_write(obj);
53304 return nativeResponseValue;
53306 // struct LDKCResult_HTLCDescriptorDecodeErrorZ HTLCDescriptor_read(struct LDKu8slice ser);
53308 export function HTLCDescriptor_read(ser: number): bigint {
53309 if(!isWasmInitialized) {
53310 throw new Error("initializeWasm() must be awaited first!");
53312 const nativeResponseValue = wasm.TS_HTLCDescriptor_read(ser);
53313 return nativeResponseValue;
53315 // MUST_USE_RES struct LDKOutPoint HTLCDescriptor_outpoint(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
53317 export function HTLCDescriptor_outpoint(this_arg: bigint): bigint {
53318 if(!isWasmInitialized) {
53319 throw new Error("initializeWasm() must be awaited first!");
53321 const nativeResponseValue = wasm.TS_HTLCDescriptor_outpoint(this_arg);
53322 return nativeResponseValue;
53324 // MUST_USE_RES struct LDKTxOut HTLCDescriptor_previous_utxo(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
53326 export function HTLCDescriptor_previous_utxo(this_arg: bigint): bigint {
53327 if(!isWasmInitialized) {
53328 throw new Error("initializeWasm() must be awaited first!");
53330 const nativeResponseValue = wasm.TS_HTLCDescriptor_previous_utxo(this_arg);
53331 return nativeResponseValue;
53333 // MUST_USE_RES struct LDKTxIn HTLCDescriptor_unsigned_tx_input(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
53335 export function HTLCDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
53336 if(!isWasmInitialized) {
53337 throw new Error("initializeWasm() must be awaited first!");
53339 const nativeResponseValue = wasm.TS_HTLCDescriptor_unsigned_tx_input(this_arg);
53340 return nativeResponseValue;
53342 // MUST_USE_RES struct LDKTxOut HTLCDescriptor_tx_output(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
53344 export function HTLCDescriptor_tx_output(this_arg: bigint): bigint {
53345 if(!isWasmInitialized) {
53346 throw new Error("initializeWasm() must be awaited first!");
53348 const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_output(this_arg);
53349 return nativeResponseValue;
53351 // MUST_USE_RES struct LDKCVec_u8Z HTLCDescriptor_witness_script(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
53353 export function HTLCDescriptor_witness_script(this_arg: bigint): number {
53354 if(!isWasmInitialized) {
53355 throw new Error("initializeWasm() must be awaited first!");
53357 const nativeResponseValue = wasm.TS_HTLCDescriptor_witness_script(this_arg);
53358 return nativeResponseValue;
53360 // MUST_USE_RES struct LDKWitness HTLCDescriptor_tx_input_witness(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, struct LDKECDSASignature signature, struct LDKu8slice witness_script);
53362 export function HTLCDescriptor_tx_input_witness(this_arg: bigint, signature: number, witness_script: number): number {
53363 if(!isWasmInitialized) {
53364 throw new Error("initializeWasm() must be awaited first!");
53366 const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_input_witness(this_arg, signature, witness_script);
53367 return nativeResponseValue;
53369 // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner HTLCDescriptor_derive_channel_signer(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
53371 export function HTLCDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
53372 if(!isWasmInitialized) {
53373 throw new Error("initializeWasm() must be awaited first!");
53375 const nativeResponseValue = wasm.TS_HTLCDescriptor_derive_channel_signer(this_arg, signer_provider);
53376 return nativeResponseValue;
53378 // void ChannelSigner_free(struct LDKChannelSigner this_ptr);
53380 export function ChannelSigner_free(this_ptr: bigint): void {
53381 if(!isWasmInitialized) {
53382 throw new Error("initializeWasm() must be awaited first!");
53384 const nativeResponseValue = wasm.TS_ChannelSigner_free(this_ptr);
53385 // debug statements here
53387 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
53389 export function Recipient_clone(orig: bigint): Recipient {
53390 if(!isWasmInitialized) {
53391 throw new Error("initializeWasm() must be awaited first!");
53393 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
53394 return nativeResponseValue;
53396 // enum LDKRecipient Recipient_node(void);
53398 export function Recipient_node(): Recipient {
53399 if(!isWasmInitialized) {
53400 throw new Error("initializeWasm() must be awaited first!");
53402 const nativeResponseValue = wasm.TS_Recipient_node();
53403 return nativeResponseValue;
53405 // enum LDKRecipient Recipient_phantom_node(void);
53407 export function Recipient_phantom_node(): Recipient {
53408 if(!isWasmInitialized) {
53409 throw new Error("initializeWasm() must be awaited first!");
53411 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
53412 return nativeResponseValue;
53414 // void EntropySource_free(struct LDKEntropySource this_ptr);
53416 export function EntropySource_free(this_ptr: bigint): void {
53417 if(!isWasmInitialized) {
53418 throw new Error("initializeWasm() must be awaited first!");
53420 const nativeResponseValue = wasm.TS_EntropySource_free(this_ptr);
53421 // debug statements here
53423 // void NodeSigner_free(struct LDKNodeSigner this_ptr);
53425 export function NodeSigner_free(this_ptr: bigint): void {
53426 if(!isWasmInitialized) {
53427 throw new Error("initializeWasm() must be awaited first!");
53429 const nativeResponseValue = wasm.TS_NodeSigner_free(this_ptr);
53430 // debug statements here
53432 // void SignerProvider_free(struct LDKSignerProvider this_ptr);
53434 export function SignerProvider_free(this_ptr: bigint): void {
53435 if(!isWasmInitialized) {
53436 throw new Error("initializeWasm() must be awaited first!");
53438 const nativeResponseValue = wasm.TS_SignerProvider_free(this_ptr);
53439 // debug statements here
53441 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
53443 export function InMemorySigner_free(this_obj: bigint): void {
53444 if(!isWasmInitialized) {
53445 throw new Error("initializeWasm() must be awaited first!");
53447 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
53448 // debug statements here
53450 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
53452 export function InMemorySigner_get_funding_key(this_ptr: bigint): number {
53453 if(!isWasmInitialized) {
53454 throw new Error("initializeWasm() must be awaited first!");
53456 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
53457 return nativeResponseValue;
53459 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
53461 export function InMemorySigner_set_funding_key(this_ptr: bigint, val: number): void {
53462 if(!isWasmInitialized) {
53463 throw new Error("initializeWasm() must be awaited first!");
53465 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
53466 // debug statements here
53468 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
53470 export function InMemorySigner_get_revocation_base_key(this_ptr: bigint): number {
53471 if(!isWasmInitialized) {
53472 throw new Error("initializeWasm() must be awaited first!");
53474 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
53475 return nativeResponseValue;
53477 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
53479 export function InMemorySigner_set_revocation_base_key(this_ptr: bigint, val: number): void {
53480 if(!isWasmInitialized) {
53481 throw new Error("initializeWasm() must be awaited first!");
53483 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
53484 // debug statements here
53486 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
53488 export function InMemorySigner_get_payment_key(this_ptr: bigint): number {
53489 if(!isWasmInitialized) {
53490 throw new Error("initializeWasm() must be awaited first!");
53492 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
53493 return nativeResponseValue;
53495 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
53497 export function InMemorySigner_set_payment_key(this_ptr: bigint, val: number): void {
53498 if(!isWasmInitialized) {
53499 throw new Error("initializeWasm() must be awaited first!");
53501 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
53502 // debug statements here
53504 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
53506 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: bigint): number {
53507 if(!isWasmInitialized) {
53508 throw new Error("initializeWasm() must be awaited first!");
53510 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
53511 return nativeResponseValue;
53513 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
53515 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: bigint, val: number): void {
53516 if(!isWasmInitialized) {
53517 throw new Error("initializeWasm() must be awaited first!");
53519 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
53520 // debug statements here
53522 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
53524 export function InMemorySigner_get_htlc_base_key(this_ptr: bigint): number {
53525 if(!isWasmInitialized) {
53526 throw new Error("initializeWasm() must be awaited first!");
53528 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
53529 return nativeResponseValue;
53531 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
53533 export function InMemorySigner_set_htlc_base_key(this_ptr: bigint, val: number): void {
53534 if(!isWasmInitialized) {
53535 throw new Error("initializeWasm() must be awaited first!");
53537 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
53538 // debug statements here
53540 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
53542 export function InMemorySigner_get_commitment_seed(this_ptr: bigint): number {
53543 if(!isWasmInitialized) {
53544 throw new Error("initializeWasm() must be awaited first!");
53546 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
53547 return nativeResponseValue;
53549 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
53551 export function InMemorySigner_set_commitment_seed(this_ptr: bigint, val: number): void {
53552 if(!isWasmInitialized) {
53553 throw new Error("initializeWasm() must be awaited first!");
53555 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
53556 // debug statements here
53558 // uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
53560 export function InMemorySigner_clone_ptr(arg: bigint): bigint {
53561 if(!isWasmInitialized) {
53562 throw new Error("initializeWasm() must be awaited first!");
53564 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
53565 return nativeResponseValue;
53567 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
53569 export function InMemorySigner_clone(orig: bigint): bigint {
53570 if(!isWasmInitialized) {
53571 throw new Error("initializeWasm() must be awaited first!");
53573 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
53574 return nativeResponseValue;
53576 // 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);
53578 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 {
53579 if(!isWasmInitialized) {
53580 throw new Error("initializeWasm() must be awaited first!");
53582 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);
53583 return nativeResponseValue;
53585 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
53587 export function InMemorySigner_counterparty_pubkeys(this_arg: bigint): bigint {
53588 if(!isWasmInitialized) {
53589 throw new Error("initializeWasm() must be awaited first!");
53591 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
53592 return nativeResponseValue;
53594 // MUST_USE_RES struct LDKCOption_u16Z InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
53596 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: bigint): bigint {
53597 if(!isWasmInitialized) {
53598 throw new Error("initializeWasm() must be awaited first!");
53600 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
53601 return nativeResponseValue;
53603 // MUST_USE_RES struct LDKCOption_u16Z InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
53605 export function InMemorySigner_holder_selected_contest_delay(this_arg: bigint): bigint {
53606 if(!isWasmInitialized) {
53607 throw new Error("initializeWasm() must be awaited first!");
53609 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
53610 return nativeResponseValue;
53612 // MUST_USE_RES struct LDKCOption_boolZ InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
53614 export function InMemorySigner_is_outbound(this_arg: bigint): bigint {
53615 if(!isWasmInitialized) {
53616 throw new Error("initializeWasm() must be awaited first!");
53618 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
53619 return nativeResponseValue;
53621 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
53623 export function InMemorySigner_funding_outpoint(this_arg: bigint): bigint {
53624 if(!isWasmInitialized) {
53625 throw new Error("initializeWasm() must be awaited first!");
53627 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
53628 return nativeResponseValue;
53630 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
53632 export function InMemorySigner_get_channel_parameters(this_arg: bigint): bigint {
53633 if(!isWasmInitialized) {
53634 throw new Error("initializeWasm() must be awaited first!");
53636 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
53637 return nativeResponseValue;
53639 // MUST_USE_RES struct LDKChannelTypeFeatures InMemorySigner_channel_type_features(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
53641 export function InMemorySigner_channel_type_features(this_arg: bigint): bigint {
53642 if(!isWasmInitialized) {
53643 throw new Error("initializeWasm() must be awaited first!");
53645 const nativeResponseValue = wasm.TS_InMemorySigner_channel_type_features(this_arg);
53646 return nativeResponseValue;
53648 // MUST_USE_RES struct LDKCResult_WitnessNoneZ InMemorySigner_sign_counterparty_payment_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR descriptor);
53650 export function InMemorySigner_sign_counterparty_payment_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
53651 if(!isWasmInitialized) {
53652 throw new Error("initializeWasm() must be awaited first!");
53654 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
53655 return nativeResponseValue;
53657 // MUST_USE_RES struct LDKCResult_WitnessNoneZ InMemorySigner_sign_dynamic_p2wsh_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR descriptor);
53659 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: bigint, spend_tx: number, input_idx: number, descriptor: bigint): bigint {
53660 if(!isWasmInitialized) {
53661 throw new Error("initializeWasm() must be awaited first!");
53663 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
53664 return nativeResponseValue;
53666 // struct LDKEntropySource InMemorySigner_as_EntropySource(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
53668 export function InMemorySigner_as_EntropySource(this_arg: bigint): bigint {
53669 if(!isWasmInitialized) {
53670 throw new Error("initializeWasm() must be awaited first!");
53672 const nativeResponseValue = wasm.TS_InMemorySigner_as_EntropySource(this_arg);
53673 return nativeResponseValue;
53675 // struct LDKChannelSigner InMemorySigner_as_ChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
53677 export function InMemorySigner_as_ChannelSigner(this_arg: bigint): bigint {
53678 if(!isWasmInitialized) {
53679 throw new Error("initializeWasm() must be awaited first!");
53681 const nativeResponseValue = wasm.TS_InMemorySigner_as_ChannelSigner(this_arg);
53682 return nativeResponseValue;
53684 // struct LDKEcdsaChannelSigner InMemorySigner_as_EcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
53686 export function InMemorySigner_as_EcdsaChannelSigner(this_arg: bigint): bigint {
53687 if(!isWasmInitialized) {
53688 throw new Error("initializeWasm() must be awaited first!");
53690 const nativeResponseValue = wasm.TS_InMemorySigner_as_EcdsaChannelSigner(this_arg);
53691 return nativeResponseValue;
53693 // struct LDKWriteableEcdsaChannelSigner InMemorySigner_as_WriteableEcdsaChannelSigner(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
53695 export function InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg: bigint): bigint {
53696 if(!isWasmInitialized) {
53697 throw new Error("initializeWasm() must be awaited first!");
53699 const nativeResponseValue = wasm.TS_InMemorySigner_as_WriteableEcdsaChannelSigner(this_arg);
53700 return nativeResponseValue;
53702 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
53704 export function InMemorySigner_write(obj: bigint): number {
53705 if(!isWasmInitialized) {
53706 throw new Error("initializeWasm() must be awaited first!");
53708 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
53709 return nativeResponseValue;
53711 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKEntropySource arg);
53713 export function InMemorySigner_read(ser: number, arg: bigint): bigint {
53714 if(!isWasmInitialized) {
53715 throw new Error("initializeWasm() must be awaited first!");
53717 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
53718 return nativeResponseValue;
53720 // void KeysManager_free(struct LDKKeysManager this_obj);
53722 export function KeysManager_free(this_obj: bigint): void {
53723 if(!isWasmInitialized) {
53724 throw new Error("initializeWasm() must be awaited first!");
53726 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
53727 // debug statements here
53729 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
53731 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): bigint {
53732 if(!isWasmInitialized) {
53733 throw new Error("initializeWasm() must be awaited first!");
53735 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
53736 return nativeResponseValue;
53738 // MUST_USE_RES struct LDKSecretKey KeysManager_get_node_secret_key(const struct LDKKeysManager *NONNULL_PTR this_arg);
53740 export function KeysManager_get_node_secret_key(this_arg: bigint): number {
53741 if(!isWasmInitialized) {
53742 throw new Error("initializeWasm() must be awaited first!");
53744 const nativeResponseValue = wasm.TS_KeysManager_get_node_secret_key(this_arg);
53745 return nativeResponseValue;
53747 // 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]);
53749 export function KeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
53750 if(!isWasmInitialized) {
53751 throw new Error("initializeWasm() must be awaited first!");
53753 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
53754 return nativeResponseValue;
53756 // 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);
53758 export function KeysManager_sign_spendable_outputs_psbt(this_arg: bigint, descriptors: number, psbt: number): bigint {
53759 if(!isWasmInitialized) {
53760 throw new Error("initializeWasm() must be awaited first!");
53762 const nativeResponseValue = wasm.TS_KeysManager_sign_spendable_outputs_psbt(this_arg, descriptors, psbt);
53763 return nativeResponseValue;
53765 // 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);
53767 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 {
53768 if(!isWasmInitialized) {
53769 throw new Error("initializeWasm() must be awaited first!");
53771 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
53772 return nativeResponseValue;
53774 // struct LDKEntropySource KeysManager_as_EntropySource(const struct LDKKeysManager *NONNULL_PTR this_arg);
53776 export function KeysManager_as_EntropySource(this_arg: bigint): bigint {
53777 if(!isWasmInitialized) {
53778 throw new Error("initializeWasm() must be awaited first!");
53780 const nativeResponseValue = wasm.TS_KeysManager_as_EntropySource(this_arg);
53781 return nativeResponseValue;
53783 // struct LDKNodeSigner KeysManager_as_NodeSigner(const struct LDKKeysManager *NONNULL_PTR this_arg);
53785 export function KeysManager_as_NodeSigner(this_arg: bigint): bigint {
53786 if(!isWasmInitialized) {
53787 throw new Error("initializeWasm() must be awaited first!");
53789 const nativeResponseValue = wasm.TS_KeysManager_as_NodeSigner(this_arg);
53790 return nativeResponseValue;
53792 // struct LDKSignerProvider KeysManager_as_SignerProvider(const struct LDKKeysManager *NONNULL_PTR this_arg);
53794 export function KeysManager_as_SignerProvider(this_arg: bigint): bigint {
53795 if(!isWasmInitialized) {
53796 throw new Error("initializeWasm() must be awaited first!");
53798 const nativeResponseValue = wasm.TS_KeysManager_as_SignerProvider(this_arg);
53799 return nativeResponseValue;
53801 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
53803 export function PhantomKeysManager_free(this_obj: bigint): void {
53804 if(!isWasmInitialized) {
53805 throw new Error("initializeWasm() must be awaited first!");
53807 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
53808 // debug statements here
53810 // struct LDKEntropySource PhantomKeysManager_as_EntropySource(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
53812 export function PhantomKeysManager_as_EntropySource(this_arg: bigint): bigint {
53813 if(!isWasmInitialized) {
53814 throw new Error("initializeWasm() must be awaited first!");
53816 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_EntropySource(this_arg);
53817 return nativeResponseValue;
53819 // struct LDKNodeSigner PhantomKeysManager_as_NodeSigner(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
53821 export function PhantomKeysManager_as_NodeSigner(this_arg: bigint): bigint {
53822 if(!isWasmInitialized) {
53823 throw new Error("initializeWasm() must be awaited first!");
53825 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_NodeSigner(this_arg);
53826 return nativeResponseValue;
53828 // struct LDKSignerProvider PhantomKeysManager_as_SignerProvider(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
53830 export function PhantomKeysManager_as_SignerProvider(this_arg: bigint): bigint {
53831 if(!isWasmInitialized) {
53832 throw new Error("initializeWasm() must be awaited first!");
53834 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_SignerProvider(this_arg);
53835 return nativeResponseValue;
53837 // 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]);
53839 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): bigint {
53840 if(!isWasmInitialized) {
53841 throw new Error("initializeWasm() must be awaited first!");
53843 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
53844 return nativeResponseValue;
53846 // 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);
53848 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 {
53849 if(!isWasmInitialized) {
53850 throw new Error("initializeWasm() must be awaited first!");
53852 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
53853 return nativeResponseValue;
53855 // 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]);
53857 export function PhantomKeysManager_derive_channel_keys(this_arg: bigint, channel_value_satoshis: bigint, params: number): bigint {
53858 if(!isWasmInitialized) {
53859 throw new Error("initializeWasm() must be awaited first!");
53861 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
53862 return nativeResponseValue;
53864 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
53866 export function PhantomKeysManager_get_node_secret_key(this_arg: bigint): number {
53867 if(!isWasmInitialized) {
53868 throw new Error("initializeWasm() must be awaited first!");
53870 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_node_secret_key(this_arg);
53871 return nativeResponseValue;
53873 // MUST_USE_RES struct LDKSecretKey PhantomKeysManager_get_phantom_node_secret_key(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
53875 export function PhantomKeysManager_get_phantom_node_secret_key(this_arg: bigint): number {
53876 if(!isWasmInitialized) {
53877 throw new Error("initializeWasm() must be awaited first!");
53879 const nativeResponseValue = wasm.TS_PhantomKeysManager_get_phantom_node_secret_key(this_arg);
53880 return nativeResponseValue;
53882 // void EcdsaChannelSigner_free(struct LDKEcdsaChannelSigner this_ptr);
53884 export function EcdsaChannelSigner_free(this_ptr: bigint): void {
53885 if(!isWasmInitialized) {
53886 throw new Error("initializeWasm() must be awaited first!");
53888 const nativeResponseValue = wasm.TS_EcdsaChannelSigner_free(this_ptr);
53889 // debug statements here
53891 // uint64_t WriteableEcdsaChannelSigner_clone_ptr(LDKWriteableEcdsaChannelSigner *NONNULL_PTR arg);
53893 export function WriteableEcdsaChannelSigner_clone_ptr(arg: bigint): bigint {
53894 if(!isWasmInitialized) {
53895 throw new Error("initializeWasm() must be awaited first!");
53897 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone_ptr(arg);
53898 return nativeResponseValue;
53900 // struct LDKWriteableEcdsaChannelSigner WriteableEcdsaChannelSigner_clone(const struct LDKWriteableEcdsaChannelSigner *NONNULL_PTR orig);
53902 export function WriteableEcdsaChannelSigner_clone(orig: bigint): bigint {
53903 if(!isWasmInitialized) {
53904 throw new Error("initializeWasm() must be awaited first!");
53906 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_clone(orig);
53907 return nativeResponseValue;
53909 // void WriteableEcdsaChannelSigner_free(struct LDKWriteableEcdsaChannelSigner this_ptr);
53911 export function WriteableEcdsaChannelSigner_free(this_ptr: bigint): void {
53912 if(!isWasmInitialized) {
53913 throw new Error("initializeWasm() must be awaited first!");
53915 const nativeResponseValue = wasm.TS_WriteableEcdsaChannelSigner_free(this_ptr);
53916 // debug statements here
53918 // void OnionMessenger_free(struct LDKOnionMessenger this_obj);
53920 export function OnionMessenger_free(this_obj: bigint): void {
53921 if(!isWasmInitialized) {
53922 throw new Error("initializeWasm() must be awaited first!");
53924 const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
53925 // debug statements here
53927 // void MessageRouter_free(struct LDKMessageRouter this_ptr);
53929 export function MessageRouter_free(this_ptr: bigint): void {
53930 if(!isWasmInitialized) {
53931 throw new Error("initializeWasm() must be awaited first!");
53933 const nativeResponseValue = wasm.TS_MessageRouter_free(this_ptr);
53934 // debug statements here
53936 // void DefaultMessageRouter_free(struct LDKDefaultMessageRouter this_obj);
53938 export function DefaultMessageRouter_free(this_obj: bigint): void {
53939 if(!isWasmInitialized) {
53940 throw new Error("initializeWasm() must be awaited first!");
53942 const nativeResponseValue = wasm.TS_DefaultMessageRouter_free(this_obj);
53943 // debug statements here
53945 // MUST_USE_RES struct LDKDefaultMessageRouter DefaultMessageRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKEntropySource entropy_source);
53947 export function DefaultMessageRouter_new(network_graph: bigint, entropy_source: bigint): bigint {
53948 if(!isWasmInitialized) {
53949 throw new Error("initializeWasm() must be awaited first!");
53951 const nativeResponseValue = wasm.TS_DefaultMessageRouter_new(network_graph, entropy_source);
53952 return nativeResponseValue;
53954 // struct LDKMessageRouter DefaultMessageRouter_as_MessageRouter(const struct LDKDefaultMessageRouter *NONNULL_PTR this_arg);
53956 export function DefaultMessageRouter_as_MessageRouter(this_arg: bigint): bigint {
53957 if(!isWasmInitialized) {
53958 throw new Error("initializeWasm() must be awaited first!");
53960 const nativeResponseValue = wasm.TS_DefaultMessageRouter_as_MessageRouter(this_arg);
53961 return nativeResponseValue;
53963 // void OnionMessagePath_free(struct LDKOnionMessagePath this_obj);
53965 export function OnionMessagePath_free(this_obj: bigint): void {
53966 if(!isWasmInitialized) {
53967 throw new Error("initializeWasm() must be awaited first!");
53969 const nativeResponseValue = wasm.TS_OnionMessagePath_free(this_obj);
53970 // debug statements here
53972 // struct LDKCVec_PublicKeyZ OnionMessagePath_get_intermediate_nodes(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
53974 export function OnionMessagePath_get_intermediate_nodes(this_ptr: bigint): number {
53975 if(!isWasmInitialized) {
53976 throw new Error("initializeWasm() must be awaited first!");
53978 const nativeResponseValue = wasm.TS_OnionMessagePath_get_intermediate_nodes(this_ptr);
53979 return nativeResponseValue;
53981 // void OnionMessagePath_set_intermediate_nodes(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKCVec_PublicKeyZ val);
53983 export function OnionMessagePath_set_intermediate_nodes(this_ptr: bigint, val: number): void {
53984 if(!isWasmInitialized) {
53985 throw new Error("initializeWasm() must be awaited first!");
53987 const nativeResponseValue = wasm.TS_OnionMessagePath_set_intermediate_nodes(this_ptr, val);
53988 // debug statements here
53990 // struct LDKDestination OnionMessagePath_get_destination(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
53992 export function OnionMessagePath_get_destination(this_ptr: bigint): bigint {
53993 if(!isWasmInitialized) {
53994 throw new Error("initializeWasm() must be awaited first!");
53996 const nativeResponseValue = wasm.TS_OnionMessagePath_get_destination(this_ptr);
53997 return nativeResponseValue;
53999 // void OnionMessagePath_set_destination(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKDestination val);
54001 export function OnionMessagePath_set_destination(this_ptr: bigint, val: bigint): void {
54002 if(!isWasmInitialized) {
54003 throw new Error("initializeWasm() must be awaited first!");
54005 const nativeResponseValue = wasm.TS_OnionMessagePath_set_destination(this_ptr, val);
54006 // debug statements here
54008 // struct LDKCOption_CVec_SocketAddressZZ OnionMessagePath_get_first_node_addresses(const struct LDKOnionMessagePath *NONNULL_PTR this_ptr);
54010 export function OnionMessagePath_get_first_node_addresses(this_ptr: bigint): bigint {
54011 if(!isWasmInitialized) {
54012 throw new Error("initializeWasm() must be awaited first!");
54014 const nativeResponseValue = wasm.TS_OnionMessagePath_get_first_node_addresses(this_ptr);
54015 return nativeResponseValue;
54017 // void OnionMessagePath_set_first_node_addresses(struct LDKOnionMessagePath *NONNULL_PTR this_ptr, struct LDKCOption_CVec_SocketAddressZZ val);
54019 export function OnionMessagePath_set_first_node_addresses(this_ptr: bigint, val: bigint): void {
54020 if(!isWasmInitialized) {
54021 throw new Error("initializeWasm() must be awaited first!");
54023 const nativeResponseValue = wasm.TS_OnionMessagePath_set_first_node_addresses(this_ptr, val);
54024 // debug statements here
54026 // MUST_USE_RES struct LDKOnionMessagePath OnionMessagePath_new(struct LDKCVec_PublicKeyZ intermediate_nodes_arg, struct LDKDestination destination_arg, struct LDKCOption_CVec_SocketAddressZZ first_node_addresses_arg);
54028 export function OnionMessagePath_new(intermediate_nodes_arg: number, destination_arg: bigint, first_node_addresses_arg: bigint): bigint {
54029 if(!isWasmInitialized) {
54030 throw new Error("initializeWasm() must be awaited first!");
54032 const nativeResponseValue = wasm.TS_OnionMessagePath_new(intermediate_nodes_arg, destination_arg, first_node_addresses_arg);
54033 return nativeResponseValue;
54035 // uint64_t OnionMessagePath_clone_ptr(LDKOnionMessagePath *NONNULL_PTR arg);
54037 export function OnionMessagePath_clone_ptr(arg: bigint): bigint {
54038 if(!isWasmInitialized) {
54039 throw new Error("initializeWasm() must be awaited first!");
54041 const nativeResponseValue = wasm.TS_OnionMessagePath_clone_ptr(arg);
54042 return nativeResponseValue;
54044 // struct LDKOnionMessagePath OnionMessagePath_clone(const struct LDKOnionMessagePath *NONNULL_PTR orig);
54046 export function OnionMessagePath_clone(orig: bigint): bigint {
54047 if(!isWasmInitialized) {
54048 throw new Error("initializeWasm() must be awaited first!");
54050 const nativeResponseValue = wasm.TS_OnionMessagePath_clone(orig);
54051 return nativeResponseValue;
54053 // MUST_USE_RES struct LDKPublicKey OnionMessagePath_first_node(const struct LDKOnionMessagePath *NONNULL_PTR this_arg);
54055 export function OnionMessagePath_first_node(this_arg: bigint): number {
54056 if(!isWasmInitialized) {
54057 throw new Error("initializeWasm() must be awaited first!");
54059 const nativeResponseValue = wasm.TS_OnionMessagePath_first_node(this_arg);
54060 return nativeResponseValue;
54062 // void Destination_free(struct LDKDestination this_ptr);
54064 export function Destination_free(this_ptr: bigint): void {
54065 if(!isWasmInitialized) {
54066 throw new Error("initializeWasm() must be awaited first!");
54068 const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
54069 // debug statements here
54071 // uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg);
54073 export function Destination_clone_ptr(arg: bigint): bigint {
54074 if(!isWasmInitialized) {
54075 throw new Error("initializeWasm() must be awaited first!");
54077 const nativeResponseValue = wasm.TS_Destination_clone_ptr(arg);
54078 return nativeResponseValue;
54080 // struct LDKDestination Destination_clone(const struct LDKDestination *NONNULL_PTR orig);
54082 export function Destination_clone(orig: bigint): bigint {
54083 if(!isWasmInitialized) {
54084 throw new Error("initializeWasm() must be awaited first!");
54086 const nativeResponseValue = wasm.TS_Destination_clone(orig);
54087 return nativeResponseValue;
54089 // struct LDKDestination Destination_node(struct LDKPublicKey a);
54091 export function Destination_node(a: number): bigint {
54092 if(!isWasmInitialized) {
54093 throw new Error("initializeWasm() must be awaited first!");
54095 const nativeResponseValue = wasm.TS_Destination_node(a);
54096 return nativeResponseValue;
54098 // struct LDKDestination Destination_blinded_path(struct LDKBlindedPath a);
54100 export function Destination_blinded_path(a: bigint): bigint {
54101 if(!isWasmInitialized) {
54102 throw new Error("initializeWasm() must be awaited first!");
54104 const nativeResponseValue = wasm.TS_Destination_blinded_path(a);
54105 return nativeResponseValue;
54107 // void SendSuccess_free(struct LDKSendSuccess this_ptr);
54109 export function SendSuccess_free(this_ptr: bigint): void {
54110 if(!isWasmInitialized) {
54111 throw new Error("initializeWasm() must be awaited first!");
54113 const nativeResponseValue = wasm.TS_SendSuccess_free(this_ptr);
54114 // debug statements here
54116 // uint64_t SendSuccess_clone_ptr(LDKSendSuccess *NONNULL_PTR arg);
54118 export function SendSuccess_clone_ptr(arg: bigint): bigint {
54119 if(!isWasmInitialized) {
54120 throw new Error("initializeWasm() must be awaited first!");
54122 const nativeResponseValue = wasm.TS_SendSuccess_clone_ptr(arg);
54123 return nativeResponseValue;
54125 // struct LDKSendSuccess SendSuccess_clone(const struct LDKSendSuccess *NONNULL_PTR orig);
54127 export function SendSuccess_clone(orig: bigint): bigint {
54128 if(!isWasmInitialized) {
54129 throw new Error("initializeWasm() must be awaited first!");
54131 const nativeResponseValue = wasm.TS_SendSuccess_clone(orig);
54132 return nativeResponseValue;
54134 // struct LDKSendSuccess SendSuccess_buffered(void);
54136 export function SendSuccess_buffered(): bigint {
54137 if(!isWasmInitialized) {
54138 throw new Error("initializeWasm() must be awaited first!");
54140 const nativeResponseValue = wasm.TS_SendSuccess_buffered();
54141 return nativeResponseValue;
54143 // struct LDKSendSuccess SendSuccess_buffered_awaiting_connection(struct LDKPublicKey a);
54145 export function SendSuccess_buffered_awaiting_connection(a: number): bigint {
54146 if(!isWasmInitialized) {
54147 throw new Error("initializeWasm() must be awaited first!");
54149 const nativeResponseValue = wasm.TS_SendSuccess_buffered_awaiting_connection(a);
54150 return nativeResponseValue;
54152 // bool SendSuccess_eq(const struct LDKSendSuccess *NONNULL_PTR a, const struct LDKSendSuccess *NONNULL_PTR b);
54154 export function SendSuccess_eq(a: bigint, b: bigint): boolean {
54155 if(!isWasmInitialized) {
54156 throw new Error("initializeWasm() must be awaited first!");
54158 const nativeResponseValue = wasm.TS_SendSuccess_eq(a, b);
54159 return nativeResponseValue;
54161 // void SendError_free(struct LDKSendError this_ptr);
54163 export function SendError_free(this_ptr: bigint): void {
54164 if(!isWasmInitialized) {
54165 throw new Error("initializeWasm() must be awaited first!");
54167 const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
54168 // debug statements here
54170 // uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
54172 export function SendError_clone_ptr(arg: bigint): bigint {
54173 if(!isWasmInitialized) {
54174 throw new Error("initializeWasm() must be awaited first!");
54176 const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
54177 return nativeResponseValue;
54179 // struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
54181 export function SendError_clone(orig: bigint): bigint {
54182 if(!isWasmInitialized) {
54183 throw new Error("initializeWasm() must be awaited first!");
54185 const nativeResponseValue = wasm.TS_SendError_clone(orig);
54186 return nativeResponseValue;
54188 // struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
54190 export function SendError_secp256k1(a: Secp256k1Error): bigint {
54191 if(!isWasmInitialized) {
54192 throw new Error("initializeWasm() must be awaited first!");
54194 const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
54195 return nativeResponseValue;
54197 // struct LDKSendError SendError_too_big_packet(void);
54199 export function SendError_too_big_packet(): bigint {
54200 if(!isWasmInitialized) {
54201 throw new Error("initializeWasm() must be awaited first!");
54203 const nativeResponseValue = wasm.TS_SendError_too_big_packet();
54204 return nativeResponseValue;
54206 // struct LDKSendError SendError_too_few_blinded_hops(void);
54208 export function SendError_too_few_blinded_hops(): bigint {
54209 if(!isWasmInitialized) {
54210 throw new Error("initializeWasm() must be awaited first!");
54212 const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
54213 return nativeResponseValue;
54215 // struct LDKSendError SendError_invalid_first_hop(struct LDKPublicKey a);
54217 export function SendError_invalid_first_hop(a: number): bigint {
54218 if(!isWasmInitialized) {
54219 throw new Error("initializeWasm() must be awaited first!");
54221 const nativeResponseValue = wasm.TS_SendError_invalid_first_hop(a);
54222 return nativeResponseValue;
54224 // struct LDKSendError SendError_path_not_found(void);
54226 export function SendError_path_not_found(): bigint {
54227 if(!isWasmInitialized) {
54228 throw new Error("initializeWasm() must be awaited first!");
54230 const nativeResponseValue = wasm.TS_SendError_path_not_found();
54231 return nativeResponseValue;
54233 // struct LDKSendError SendError_invalid_message(void);
54235 export function SendError_invalid_message(): bigint {
54236 if(!isWasmInitialized) {
54237 throw new Error("initializeWasm() must be awaited first!");
54239 const nativeResponseValue = wasm.TS_SendError_invalid_message();
54240 return nativeResponseValue;
54242 // struct LDKSendError SendError_buffer_full(void);
54244 export function SendError_buffer_full(): bigint {
54245 if(!isWasmInitialized) {
54246 throw new Error("initializeWasm() must be awaited first!");
54248 const nativeResponseValue = wasm.TS_SendError_buffer_full();
54249 return nativeResponseValue;
54251 // struct LDKSendError SendError_get_node_id_failed(void);
54253 export function SendError_get_node_id_failed(): bigint {
54254 if(!isWasmInitialized) {
54255 throw new Error("initializeWasm() must be awaited first!");
54257 const nativeResponseValue = wasm.TS_SendError_get_node_id_failed();
54258 return nativeResponseValue;
54260 // struct LDKSendError SendError_blinded_path_advance_failed(void);
54262 export function SendError_blinded_path_advance_failed(): bigint {
54263 if(!isWasmInitialized) {
54264 throw new Error("initializeWasm() must be awaited first!");
54266 const nativeResponseValue = wasm.TS_SendError_blinded_path_advance_failed();
54267 return nativeResponseValue;
54269 // bool SendError_eq(const struct LDKSendError *NONNULL_PTR a, const struct LDKSendError *NONNULL_PTR b);
54271 export function SendError_eq(a: bigint, b: bigint): boolean {
54272 if(!isWasmInitialized) {
54273 throw new Error("initializeWasm() must be awaited first!");
54275 const nativeResponseValue = wasm.TS_SendError_eq(a, b);
54276 return nativeResponseValue;
54278 // void CustomOnionMessageHandler_free(struct LDKCustomOnionMessageHandler this_ptr);
54280 export function CustomOnionMessageHandler_free(this_ptr: bigint): void {
54281 if(!isWasmInitialized) {
54282 throw new Error("initializeWasm() must be awaited first!");
54284 const nativeResponseValue = wasm.TS_CustomOnionMessageHandler_free(this_ptr);
54285 // debug statements here
54287 // void PeeledOnion_free(struct LDKPeeledOnion this_ptr);
54289 export function PeeledOnion_free(this_ptr: bigint): void {
54290 if(!isWasmInitialized) {
54291 throw new Error("initializeWasm() must be awaited first!");
54293 const nativeResponseValue = wasm.TS_PeeledOnion_free(this_ptr);
54294 // debug statements here
54296 // uint64_t PeeledOnion_clone_ptr(LDKPeeledOnion *NONNULL_PTR arg);
54298 export function PeeledOnion_clone_ptr(arg: bigint): bigint {
54299 if(!isWasmInitialized) {
54300 throw new Error("initializeWasm() must be awaited first!");
54302 const nativeResponseValue = wasm.TS_PeeledOnion_clone_ptr(arg);
54303 return nativeResponseValue;
54305 // struct LDKPeeledOnion PeeledOnion_clone(const struct LDKPeeledOnion *NONNULL_PTR orig);
54307 export function PeeledOnion_clone(orig: bigint): bigint {
54308 if(!isWasmInitialized) {
54309 throw new Error("initializeWasm() must be awaited first!");
54311 const nativeResponseValue = wasm.TS_PeeledOnion_clone(orig);
54312 return nativeResponseValue;
54314 // struct LDKPeeledOnion PeeledOnion_forward(struct LDKPublicKey a, struct LDKOnionMessage b);
54316 export function PeeledOnion_forward(a: number, b: bigint): bigint {
54317 if(!isWasmInitialized) {
54318 throw new Error("initializeWasm() must be awaited first!");
54320 const nativeResponseValue = wasm.TS_PeeledOnion_forward(a, b);
54321 return nativeResponseValue;
54323 // struct LDKPeeledOnion PeeledOnion_receive(struct LDKParsedOnionMessageContents a, struct LDKThirtyTwoBytes b, struct LDKBlindedPath c);
54325 export function PeeledOnion_receive(a: bigint, b: number, c: bigint): bigint {
54326 if(!isWasmInitialized) {
54327 throw new Error("initializeWasm() must be awaited first!");
54329 const nativeResponseValue = wasm.TS_PeeledOnion_receive(a, b, c);
54330 return nativeResponseValue;
54332 // struct LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ 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);
54334 export function create_onion_message(entropy_source: bigint, node_signer: bigint, path: bigint, contents: bigint, reply_path: bigint): bigint {
54335 if(!isWasmInitialized) {
54336 throw new Error("initializeWasm() must be awaited first!");
54338 const nativeResponseValue = wasm.TS_create_onion_message(entropy_source, node_signer, path, contents, reply_path);
54339 return nativeResponseValue;
54341 // struct LDKCResult_PeeledOnionNoneZ peel_onion_message(const struct LDKOnionMessage *NONNULL_PTR msg, struct LDKNodeSigner node_signer, struct LDKLogger logger, struct LDKCustomOnionMessageHandler custom_handler);
54343 export function peel_onion_message(msg: bigint, node_signer: bigint, logger: bigint, custom_handler: bigint): bigint {
54344 if(!isWasmInitialized) {
54345 throw new Error("initializeWasm() must be awaited first!");
54347 const nativeResponseValue = wasm.TS_peel_onion_message(msg, node_signer, logger, custom_handler);
54348 return nativeResponseValue;
54350 // 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);
54352 export function OnionMessenger_new(entropy_source: bigint, node_signer: bigint, logger: bigint, message_router: bigint, offers_handler: bigint, custom_handler: bigint): bigint {
54353 if(!isWasmInitialized) {
54354 throw new Error("initializeWasm() must be awaited first!");
54356 const nativeResponseValue = wasm.TS_OnionMessenger_new(entropy_source, node_signer, logger, message_router, offers_handler, custom_handler);
54357 return nativeResponseValue;
54359 // MUST_USE_RES struct LDKCResult_SendSuccessSendErrorZ OnionMessenger_send_onion_message(const struct LDKOnionMessenger *NONNULL_PTR this_arg, struct LDKOnionMessageContents contents, struct LDKDestination destination, struct LDKBlindedPath reply_path);
54361 export function OnionMessenger_send_onion_message(this_arg: bigint, contents: bigint, destination: bigint, reply_path: bigint): bigint {
54362 if(!isWasmInitialized) {
54363 throw new Error("initializeWasm() must be awaited first!");
54365 const nativeResponseValue = wasm.TS_OnionMessenger_send_onion_message(this_arg, contents, destination, reply_path);
54366 return nativeResponseValue;
54368 // struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
54370 export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
54371 if(!isWasmInitialized) {
54372 throw new Error("initializeWasm() must be awaited first!");
54374 const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
54375 return nativeResponseValue;
54377 // void OffersMessageHandler_free(struct LDKOffersMessageHandler this_ptr);
54379 export function OffersMessageHandler_free(this_ptr: bigint): void {
54380 if(!isWasmInitialized) {
54381 throw new Error("initializeWasm() must be awaited first!");
54383 const nativeResponseValue = wasm.TS_OffersMessageHandler_free(this_ptr);
54384 // debug statements here
54386 // void OffersMessage_free(struct LDKOffersMessage this_ptr);
54388 export function OffersMessage_free(this_ptr: bigint): void {
54389 if(!isWasmInitialized) {
54390 throw new Error("initializeWasm() must be awaited first!");
54392 const nativeResponseValue = wasm.TS_OffersMessage_free(this_ptr);
54393 // debug statements here
54395 // uint64_t OffersMessage_clone_ptr(LDKOffersMessage *NONNULL_PTR arg);
54397 export function OffersMessage_clone_ptr(arg: bigint): bigint {
54398 if(!isWasmInitialized) {
54399 throw new Error("initializeWasm() must be awaited first!");
54401 const nativeResponseValue = wasm.TS_OffersMessage_clone_ptr(arg);
54402 return nativeResponseValue;
54404 // struct LDKOffersMessage OffersMessage_clone(const struct LDKOffersMessage *NONNULL_PTR orig);
54406 export function OffersMessage_clone(orig: bigint): bigint {
54407 if(!isWasmInitialized) {
54408 throw new Error("initializeWasm() must be awaited first!");
54410 const nativeResponseValue = wasm.TS_OffersMessage_clone(orig);
54411 return nativeResponseValue;
54413 // struct LDKOffersMessage OffersMessage_invoice_request(struct LDKInvoiceRequest a);
54415 export function OffersMessage_invoice_request(a: bigint): bigint {
54416 if(!isWasmInitialized) {
54417 throw new Error("initializeWasm() must be awaited first!");
54419 const nativeResponseValue = wasm.TS_OffersMessage_invoice_request(a);
54420 return nativeResponseValue;
54422 // struct LDKOffersMessage OffersMessage_invoice(struct LDKBolt12Invoice a);
54424 export function OffersMessage_invoice(a: bigint): bigint {
54425 if(!isWasmInitialized) {
54426 throw new Error("initializeWasm() must be awaited first!");
54428 const nativeResponseValue = wasm.TS_OffersMessage_invoice(a);
54429 return nativeResponseValue;
54431 // struct LDKOffersMessage OffersMessage_invoice_error(struct LDKInvoiceError a);
54433 export function OffersMessage_invoice_error(a: bigint): bigint {
54434 if(!isWasmInitialized) {
54435 throw new Error("initializeWasm() must be awaited first!");
54437 const nativeResponseValue = wasm.TS_OffersMessage_invoice_error(a);
54438 return nativeResponseValue;
54440 // MUST_USE_RES bool OffersMessage_is_known_type(uint64_t tlv_type);
54442 export function OffersMessage_is_known_type(tlv_type: bigint): boolean {
54443 if(!isWasmInitialized) {
54444 throw new Error("initializeWasm() must be awaited first!");
54446 const nativeResponseValue = wasm.TS_OffersMessage_is_known_type(tlv_type);
54447 return nativeResponseValue;
54449 // struct LDKOnionMessageContents OffersMessage_as_OnionMessageContents(const struct LDKOffersMessage *NONNULL_PTR this_arg);
54451 export function OffersMessage_as_OnionMessageContents(this_arg: bigint): bigint {
54452 if(!isWasmInitialized) {
54453 throw new Error("initializeWasm() must be awaited first!");
54455 const nativeResponseValue = wasm.TS_OffersMessage_as_OnionMessageContents(this_arg);
54456 return nativeResponseValue;
54458 // struct LDKCVec_u8Z OffersMessage_write(const struct LDKOffersMessage *NONNULL_PTR obj);
54460 export function OffersMessage_write(obj: bigint): number {
54461 if(!isWasmInitialized) {
54462 throw new Error("initializeWasm() must be awaited first!");
54464 const nativeResponseValue = wasm.TS_OffersMessage_write(obj);
54465 return nativeResponseValue;
54467 // struct LDKCResult_OffersMessageDecodeErrorZ OffersMessage_read(struct LDKu8slice ser, uint64_t arg_a, const struct LDKLogger *NONNULL_PTR arg_b);
54469 export function OffersMessage_read(ser: number, arg_a: bigint, arg_b: bigint): bigint {
54470 if(!isWasmInitialized) {
54471 throw new Error("initializeWasm() must be awaited first!");
54473 const nativeResponseValue = wasm.TS_OffersMessage_read(ser, arg_a, arg_b);
54474 return nativeResponseValue;
54476 // void Packet_free(struct LDKPacket this_obj);
54478 export function Packet_free(this_obj: bigint): void {
54479 if(!isWasmInitialized) {
54480 throw new Error("initializeWasm() must be awaited first!");
54482 const nativeResponseValue = wasm.TS_Packet_free(this_obj);
54483 // debug statements here
54485 // uint8_t Packet_get_version(const struct LDKPacket *NONNULL_PTR this_ptr);
54487 export function Packet_get_version(this_ptr: bigint): number {
54488 if(!isWasmInitialized) {
54489 throw new Error("initializeWasm() must be awaited first!");
54491 const nativeResponseValue = wasm.TS_Packet_get_version(this_ptr);
54492 return nativeResponseValue;
54494 // void Packet_set_version(struct LDKPacket *NONNULL_PTR this_ptr, uint8_t val);
54496 export function Packet_set_version(this_ptr: bigint, val: number): void {
54497 if(!isWasmInitialized) {
54498 throw new Error("initializeWasm() must be awaited first!");
54500 const nativeResponseValue = wasm.TS_Packet_set_version(this_ptr, val);
54501 // debug statements here
54503 // struct LDKPublicKey Packet_get_public_key(const struct LDKPacket *NONNULL_PTR this_ptr);
54505 export function Packet_get_public_key(this_ptr: bigint): number {
54506 if(!isWasmInitialized) {
54507 throw new Error("initializeWasm() must be awaited first!");
54509 const nativeResponseValue = wasm.TS_Packet_get_public_key(this_ptr);
54510 return nativeResponseValue;
54512 // void Packet_set_public_key(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKPublicKey val);
54514 export function Packet_set_public_key(this_ptr: bigint, val: number): void {
54515 if(!isWasmInitialized) {
54516 throw new Error("initializeWasm() must be awaited first!");
54518 const nativeResponseValue = wasm.TS_Packet_set_public_key(this_ptr, val);
54519 // debug statements here
54521 // struct LDKCVec_u8Z Packet_get_hop_data(const struct LDKPacket *NONNULL_PTR this_ptr);
54523 export function Packet_get_hop_data(this_ptr: bigint): number {
54524 if(!isWasmInitialized) {
54525 throw new Error("initializeWasm() must be awaited first!");
54527 const nativeResponseValue = wasm.TS_Packet_get_hop_data(this_ptr);
54528 return nativeResponseValue;
54530 // void Packet_set_hop_data(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
54532 export function Packet_set_hop_data(this_ptr: bigint, val: number): void {
54533 if(!isWasmInitialized) {
54534 throw new Error("initializeWasm() must be awaited first!");
54536 const nativeResponseValue = wasm.TS_Packet_set_hop_data(this_ptr, val);
54537 // debug statements here
54539 // const uint8_t (*Packet_get_hmac(const struct LDKPacket *NONNULL_PTR this_ptr))[32];
54541 export function Packet_get_hmac(this_ptr: bigint): number {
54542 if(!isWasmInitialized) {
54543 throw new Error("initializeWasm() must be awaited first!");
54545 const nativeResponseValue = wasm.TS_Packet_get_hmac(this_ptr);
54546 return nativeResponseValue;
54548 // void Packet_set_hmac(struct LDKPacket *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
54550 export function Packet_set_hmac(this_ptr: bigint, val: number): void {
54551 if(!isWasmInitialized) {
54552 throw new Error("initializeWasm() must be awaited first!");
54554 const nativeResponseValue = wasm.TS_Packet_set_hmac(this_ptr, val);
54555 // debug statements here
54557 // 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);
54559 export function Packet_new(version_arg: number, public_key_arg: number, hop_data_arg: number, hmac_arg: number): bigint {
54560 if(!isWasmInitialized) {
54561 throw new Error("initializeWasm() must be awaited first!");
54563 const nativeResponseValue = wasm.TS_Packet_new(version_arg, public_key_arg, hop_data_arg, hmac_arg);
54564 return nativeResponseValue;
54566 // uint64_t Packet_clone_ptr(LDKPacket *NONNULL_PTR arg);
54568 export function Packet_clone_ptr(arg: bigint): bigint {
54569 if(!isWasmInitialized) {
54570 throw new Error("initializeWasm() must be awaited first!");
54572 const nativeResponseValue = wasm.TS_Packet_clone_ptr(arg);
54573 return nativeResponseValue;
54575 // struct LDKPacket Packet_clone(const struct LDKPacket *NONNULL_PTR orig);
54577 export function Packet_clone(orig: bigint): bigint {
54578 if(!isWasmInitialized) {
54579 throw new Error("initializeWasm() must be awaited first!");
54581 const nativeResponseValue = wasm.TS_Packet_clone(orig);
54582 return nativeResponseValue;
54584 // uint64_t Packet_hash(const struct LDKPacket *NONNULL_PTR o);
54586 export function Packet_hash(o: bigint): bigint {
54587 if(!isWasmInitialized) {
54588 throw new Error("initializeWasm() must be awaited first!");
54590 const nativeResponseValue = wasm.TS_Packet_hash(o);
54591 return nativeResponseValue;
54593 // bool Packet_eq(const struct LDKPacket *NONNULL_PTR a, const struct LDKPacket *NONNULL_PTR b);
54595 export function Packet_eq(a: bigint, b: bigint): boolean {
54596 if(!isWasmInitialized) {
54597 throw new Error("initializeWasm() must be awaited first!");
54599 const nativeResponseValue = wasm.TS_Packet_eq(a, b);
54600 return nativeResponseValue;
54602 // struct LDKCVec_u8Z Packet_write(const struct LDKPacket *NONNULL_PTR obj);
54604 export function Packet_write(obj: bigint): number {
54605 if(!isWasmInitialized) {
54606 throw new Error("initializeWasm() must be awaited first!");
54608 const nativeResponseValue = wasm.TS_Packet_write(obj);
54609 return nativeResponseValue;
54611 // void ParsedOnionMessageContents_free(struct LDKParsedOnionMessageContents this_ptr);
54613 export function ParsedOnionMessageContents_free(this_ptr: bigint): void {
54614 if(!isWasmInitialized) {
54615 throw new Error("initializeWasm() must be awaited first!");
54617 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_free(this_ptr);
54618 // debug statements here
54620 // uint64_t ParsedOnionMessageContents_clone_ptr(LDKParsedOnionMessageContents *NONNULL_PTR arg);
54622 export function ParsedOnionMessageContents_clone_ptr(arg: bigint): bigint {
54623 if(!isWasmInitialized) {
54624 throw new Error("initializeWasm() must be awaited first!");
54626 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_clone_ptr(arg);
54627 return nativeResponseValue;
54629 // struct LDKParsedOnionMessageContents ParsedOnionMessageContents_clone(const struct LDKParsedOnionMessageContents *NONNULL_PTR orig);
54631 export function ParsedOnionMessageContents_clone(orig: bigint): bigint {
54632 if(!isWasmInitialized) {
54633 throw new Error("initializeWasm() must be awaited first!");
54635 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_clone(orig);
54636 return nativeResponseValue;
54638 // struct LDKParsedOnionMessageContents ParsedOnionMessageContents_offers(struct LDKOffersMessage a);
54640 export function ParsedOnionMessageContents_offers(a: bigint): bigint {
54641 if(!isWasmInitialized) {
54642 throw new Error("initializeWasm() must be awaited first!");
54644 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_offers(a);
54645 return nativeResponseValue;
54647 // struct LDKParsedOnionMessageContents ParsedOnionMessageContents_custom(struct LDKOnionMessageContents a);
54649 export function ParsedOnionMessageContents_custom(a: bigint): bigint {
54650 if(!isWasmInitialized) {
54651 throw new Error("initializeWasm() must be awaited first!");
54653 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_custom(a);
54654 return nativeResponseValue;
54656 // struct LDKOnionMessageContents ParsedOnionMessageContents_as_OnionMessageContents(const struct LDKParsedOnionMessageContents *NONNULL_PTR this_arg);
54658 export function ParsedOnionMessageContents_as_OnionMessageContents(this_arg: bigint): bigint {
54659 if(!isWasmInitialized) {
54660 throw new Error("initializeWasm() must be awaited first!");
54662 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_as_OnionMessageContents(this_arg);
54663 return nativeResponseValue;
54665 // struct LDKCVec_u8Z ParsedOnionMessageContents_write(const struct LDKParsedOnionMessageContents *NONNULL_PTR obj);
54667 export function ParsedOnionMessageContents_write(obj: bigint): number {
54668 if(!isWasmInitialized) {
54669 throw new Error("initializeWasm() must be awaited first!");
54671 const nativeResponseValue = wasm.TS_ParsedOnionMessageContents_write(obj);
54672 return nativeResponseValue;
54674 // uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg);
54676 export function OnionMessageContents_clone_ptr(arg: bigint): bigint {
54677 if(!isWasmInitialized) {
54678 throw new Error("initializeWasm() must be awaited first!");
54680 const nativeResponseValue = wasm.TS_OnionMessageContents_clone_ptr(arg);
54681 return nativeResponseValue;
54683 // struct LDKOnionMessageContents OnionMessageContents_clone(const struct LDKOnionMessageContents *NONNULL_PTR orig);
54685 export function OnionMessageContents_clone(orig: bigint): bigint {
54686 if(!isWasmInitialized) {
54687 throw new Error("initializeWasm() must be awaited first!");
54689 const nativeResponseValue = wasm.TS_OnionMessageContents_clone(orig);
54690 return nativeResponseValue;
54692 // void OnionMessageContents_free(struct LDKOnionMessageContents this_ptr);
54694 export function OnionMessageContents_free(this_ptr: bigint): void {
54695 if(!isWasmInitialized) {
54696 throw new Error("initializeWasm() must be awaited first!");
54698 const nativeResponseValue = wasm.TS_OnionMessageContents_free(this_ptr);
54699 // debug statements here
54701 // void BlindedPath_free(struct LDKBlindedPath this_obj);
54703 export function BlindedPath_free(this_obj: bigint): void {
54704 if(!isWasmInitialized) {
54705 throw new Error("initializeWasm() must be awaited first!");
54707 const nativeResponseValue = wasm.TS_BlindedPath_free(this_obj);
54708 // debug statements here
54710 // struct LDKPublicKey BlindedPath_get_introduction_node_id(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
54712 export function BlindedPath_get_introduction_node_id(this_ptr: bigint): number {
54713 if(!isWasmInitialized) {
54714 throw new Error("initializeWasm() must be awaited first!");
54716 const nativeResponseValue = wasm.TS_BlindedPath_get_introduction_node_id(this_ptr);
54717 return nativeResponseValue;
54719 // void BlindedPath_set_introduction_node_id(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKPublicKey val);
54721 export function BlindedPath_set_introduction_node_id(this_ptr: bigint, val: number): void {
54722 if(!isWasmInitialized) {
54723 throw new Error("initializeWasm() must be awaited first!");
54725 const nativeResponseValue = wasm.TS_BlindedPath_set_introduction_node_id(this_ptr, val);
54726 // debug statements here
54728 // struct LDKPublicKey BlindedPath_get_blinding_point(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
54730 export function BlindedPath_get_blinding_point(this_ptr: bigint): number {
54731 if(!isWasmInitialized) {
54732 throw new Error("initializeWasm() must be awaited first!");
54734 const nativeResponseValue = wasm.TS_BlindedPath_get_blinding_point(this_ptr);
54735 return nativeResponseValue;
54737 // void BlindedPath_set_blinding_point(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKPublicKey val);
54739 export function BlindedPath_set_blinding_point(this_ptr: bigint, val: number): void {
54740 if(!isWasmInitialized) {
54741 throw new Error("initializeWasm() must be awaited first!");
54743 const nativeResponseValue = wasm.TS_BlindedPath_set_blinding_point(this_ptr, val);
54744 // debug statements here
54746 // struct LDKCVec_BlindedHopZ BlindedPath_get_blinded_hops(const struct LDKBlindedPath *NONNULL_PTR this_ptr);
54748 export function BlindedPath_get_blinded_hops(this_ptr: bigint): number {
54749 if(!isWasmInitialized) {
54750 throw new Error("initializeWasm() must be awaited first!");
54752 const nativeResponseValue = wasm.TS_BlindedPath_get_blinded_hops(this_ptr);
54753 return nativeResponseValue;
54755 // void BlindedPath_set_blinded_hops(struct LDKBlindedPath *NONNULL_PTR this_ptr, struct LDKCVec_BlindedHopZ val);
54757 export function BlindedPath_set_blinded_hops(this_ptr: bigint, val: number): void {
54758 if(!isWasmInitialized) {
54759 throw new Error("initializeWasm() must be awaited first!");
54761 const nativeResponseValue = wasm.TS_BlindedPath_set_blinded_hops(this_ptr, val);
54762 // debug statements here
54764 // MUST_USE_RES struct LDKBlindedPath BlindedPath_new(struct LDKPublicKey introduction_node_id_arg, struct LDKPublicKey blinding_point_arg, struct LDKCVec_BlindedHopZ blinded_hops_arg);
54766 export function BlindedPath_new(introduction_node_id_arg: number, blinding_point_arg: number, blinded_hops_arg: number): bigint {
54767 if(!isWasmInitialized) {
54768 throw new Error("initializeWasm() must be awaited first!");
54770 const nativeResponseValue = wasm.TS_BlindedPath_new(introduction_node_id_arg, blinding_point_arg, blinded_hops_arg);
54771 return nativeResponseValue;
54773 // uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg);
54775 export function BlindedPath_clone_ptr(arg: bigint): bigint {
54776 if(!isWasmInitialized) {
54777 throw new Error("initializeWasm() must be awaited first!");
54779 const nativeResponseValue = wasm.TS_BlindedPath_clone_ptr(arg);
54780 return nativeResponseValue;
54782 // struct LDKBlindedPath BlindedPath_clone(const struct LDKBlindedPath *NONNULL_PTR orig);
54784 export function BlindedPath_clone(orig: bigint): bigint {
54785 if(!isWasmInitialized) {
54786 throw new Error("initializeWasm() must be awaited first!");
54788 const nativeResponseValue = wasm.TS_BlindedPath_clone(orig);
54789 return nativeResponseValue;
54791 // uint64_t BlindedPath_hash(const struct LDKBlindedPath *NONNULL_PTR o);
54793 export function BlindedPath_hash(o: bigint): bigint {
54794 if(!isWasmInitialized) {
54795 throw new Error("initializeWasm() must be awaited first!");
54797 const nativeResponseValue = wasm.TS_BlindedPath_hash(o);
54798 return nativeResponseValue;
54800 // bool BlindedPath_eq(const struct LDKBlindedPath *NONNULL_PTR a, const struct LDKBlindedPath *NONNULL_PTR b);
54802 export function BlindedPath_eq(a: bigint, b: bigint): boolean {
54803 if(!isWasmInitialized) {
54804 throw new Error("initializeWasm() must be awaited first!");
54806 const nativeResponseValue = wasm.TS_BlindedPath_eq(a, b);
54807 return nativeResponseValue;
54809 // void BlindedHop_free(struct LDKBlindedHop this_obj);
54811 export function BlindedHop_free(this_obj: bigint): void {
54812 if(!isWasmInitialized) {
54813 throw new Error("initializeWasm() must be awaited first!");
54815 const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
54816 // debug statements here
54818 // struct LDKPublicKey BlindedHop_get_blinded_node_id(const struct LDKBlindedHop *NONNULL_PTR this_ptr);
54820 export function BlindedHop_get_blinded_node_id(this_ptr: bigint): number {
54821 if(!isWasmInitialized) {
54822 throw new Error("initializeWasm() must be awaited first!");
54824 const nativeResponseValue = wasm.TS_BlindedHop_get_blinded_node_id(this_ptr);
54825 return nativeResponseValue;
54827 // void BlindedHop_set_blinded_node_id(struct LDKBlindedHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
54829 export function BlindedHop_set_blinded_node_id(this_ptr: bigint, val: number): void {
54830 if(!isWasmInitialized) {
54831 throw new Error("initializeWasm() must be awaited first!");
54833 const nativeResponseValue = wasm.TS_BlindedHop_set_blinded_node_id(this_ptr, val);
54834 // debug statements here
54836 // struct LDKCVec_u8Z BlindedHop_get_encrypted_payload(const struct LDKBlindedHop *NONNULL_PTR this_ptr);
54838 export function BlindedHop_get_encrypted_payload(this_ptr: bigint): number {
54839 if(!isWasmInitialized) {
54840 throw new Error("initializeWasm() must be awaited first!");
54842 const nativeResponseValue = wasm.TS_BlindedHop_get_encrypted_payload(this_ptr);
54843 return nativeResponseValue;
54845 // void BlindedHop_set_encrypted_payload(struct LDKBlindedHop *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
54847 export function BlindedHop_set_encrypted_payload(this_ptr: bigint, val: number): void {
54848 if(!isWasmInitialized) {
54849 throw new Error("initializeWasm() must be awaited first!");
54851 const nativeResponseValue = wasm.TS_BlindedHop_set_encrypted_payload(this_ptr, val);
54852 // debug statements here
54854 // MUST_USE_RES struct LDKBlindedHop BlindedHop_new(struct LDKPublicKey blinded_node_id_arg, struct LDKCVec_u8Z encrypted_payload_arg);
54856 export function BlindedHop_new(blinded_node_id_arg: number, encrypted_payload_arg: number): bigint {
54857 if(!isWasmInitialized) {
54858 throw new Error("initializeWasm() must be awaited first!");
54860 const nativeResponseValue = wasm.TS_BlindedHop_new(blinded_node_id_arg, encrypted_payload_arg);
54861 return nativeResponseValue;
54863 // uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg);
54865 export function BlindedHop_clone_ptr(arg: bigint): bigint {
54866 if(!isWasmInitialized) {
54867 throw new Error("initializeWasm() must be awaited first!");
54869 const nativeResponseValue = wasm.TS_BlindedHop_clone_ptr(arg);
54870 return nativeResponseValue;
54872 // struct LDKBlindedHop BlindedHop_clone(const struct LDKBlindedHop *NONNULL_PTR orig);
54874 export function BlindedHop_clone(orig: bigint): bigint {
54875 if(!isWasmInitialized) {
54876 throw new Error("initializeWasm() must be awaited first!");
54878 const nativeResponseValue = wasm.TS_BlindedHop_clone(orig);
54879 return nativeResponseValue;
54881 // uint64_t BlindedHop_hash(const struct LDKBlindedHop *NONNULL_PTR o);
54883 export function BlindedHop_hash(o: bigint): bigint {
54884 if(!isWasmInitialized) {
54885 throw new Error("initializeWasm() must be awaited first!");
54887 const nativeResponseValue = wasm.TS_BlindedHop_hash(o);
54888 return nativeResponseValue;
54890 // bool BlindedHop_eq(const struct LDKBlindedHop *NONNULL_PTR a, const struct LDKBlindedHop *NONNULL_PTR b);
54892 export function BlindedHop_eq(a: bigint, b: bigint): boolean {
54893 if(!isWasmInitialized) {
54894 throw new Error("initializeWasm() must be awaited first!");
54896 const nativeResponseValue = wasm.TS_BlindedHop_eq(a, b);
54897 return nativeResponseValue;
54899 // MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_one_hop_for_message(struct LDKPublicKey recipient_node_id, const struct LDKEntropySource *NONNULL_PTR entropy_source);
54901 export function BlindedPath_one_hop_for_message(recipient_node_id: number, entropy_source: bigint): bigint {
54902 if(!isWasmInitialized) {
54903 throw new Error("initializeWasm() must be awaited first!");
54905 const nativeResponseValue = wasm.TS_BlindedPath_one_hop_for_message(recipient_node_id, entropy_source);
54906 return nativeResponseValue;
54908 // MUST_USE_RES struct LDKCResult_BlindedPathNoneZ BlindedPath_new_for_message(struct LDKCVec_PublicKeyZ node_pks, const struct LDKEntropySource *NONNULL_PTR entropy_source);
54910 export function BlindedPath_new_for_message(node_pks: number, entropy_source: bigint): bigint {
54911 if(!isWasmInitialized) {
54912 throw new Error("initializeWasm() must be awaited first!");
54914 const nativeResponseValue = wasm.TS_BlindedPath_new_for_message(node_pks, entropy_source);
54915 return nativeResponseValue;
54917 // 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);
54919 export function BlindedPath_one_hop_for_payment(payee_node_id: number, payee_tlvs: bigint, entropy_source: bigint): bigint {
54920 if(!isWasmInitialized) {
54921 throw new Error("initializeWasm() must be awaited first!");
54923 const nativeResponseValue = wasm.TS_BlindedPath_one_hop_for_payment(payee_node_id, payee_tlvs, entropy_source);
54924 return nativeResponseValue;
54926 // MUST_USE_RES struct LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ BlindedPath_new_for_payment(struct LDKCVec_ForwardNodeZ intermediate_nodes, struct LDKPublicKey payee_node_id, struct LDKReceiveTlvs payee_tlvs, uint64_t htlc_maximum_msat, const struct LDKEntropySource *NONNULL_PTR entropy_source);
54928 export function BlindedPath_new_for_payment(intermediate_nodes: number, payee_node_id: number, payee_tlvs: bigint, htlc_maximum_msat: bigint, entropy_source: bigint): bigint {
54929 if(!isWasmInitialized) {
54930 throw new Error("initializeWasm() must be awaited first!");
54932 const nativeResponseValue = wasm.TS_BlindedPath_new_for_payment(intermediate_nodes, payee_node_id, payee_tlvs, htlc_maximum_msat, entropy_source);
54933 return nativeResponseValue;
54935 // struct LDKCVec_u8Z BlindedPath_write(const struct LDKBlindedPath *NONNULL_PTR obj);
54937 export function BlindedPath_write(obj: bigint): number {
54938 if(!isWasmInitialized) {
54939 throw new Error("initializeWasm() must be awaited first!");
54941 const nativeResponseValue = wasm.TS_BlindedPath_write(obj);
54942 return nativeResponseValue;
54944 // struct LDKCResult_BlindedPathDecodeErrorZ BlindedPath_read(struct LDKu8slice ser);
54946 export function BlindedPath_read(ser: number): bigint {
54947 if(!isWasmInitialized) {
54948 throw new Error("initializeWasm() must be awaited first!");
54950 const nativeResponseValue = wasm.TS_BlindedPath_read(ser);
54951 return nativeResponseValue;
54953 // struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
54955 export function BlindedHop_write(obj: bigint): number {
54956 if(!isWasmInitialized) {
54957 throw new Error("initializeWasm() must be awaited first!");
54959 const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
54960 return nativeResponseValue;
54962 // struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
54964 export function BlindedHop_read(ser: number): bigint {
54965 if(!isWasmInitialized) {
54966 throw new Error("initializeWasm() must be awaited first!");
54968 const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
54969 return nativeResponseValue;
54971 // void ForwardNode_free(struct LDKForwardNode this_obj);
54973 export function ForwardNode_free(this_obj: bigint): void {
54974 if(!isWasmInitialized) {
54975 throw new Error("initializeWasm() must be awaited first!");
54977 const nativeResponseValue = wasm.TS_ForwardNode_free(this_obj);
54978 // debug statements here
54980 // struct LDKForwardTlvs ForwardNode_get_tlvs(const struct LDKForwardNode *NONNULL_PTR this_ptr);
54982 export function ForwardNode_get_tlvs(this_ptr: bigint): bigint {
54983 if(!isWasmInitialized) {
54984 throw new Error("initializeWasm() must be awaited first!");
54986 const nativeResponseValue = wasm.TS_ForwardNode_get_tlvs(this_ptr);
54987 return nativeResponseValue;
54989 // void ForwardNode_set_tlvs(struct LDKForwardNode *NONNULL_PTR this_ptr, struct LDKForwardTlvs val);
54991 export function ForwardNode_set_tlvs(this_ptr: bigint, val: bigint): void {
54992 if(!isWasmInitialized) {
54993 throw new Error("initializeWasm() must be awaited first!");
54995 const nativeResponseValue = wasm.TS_ForwardNode_set_tlvs(this_ptr, val);
54996 // debug statements here
54998 // struct LDKPublicKey ForwardNode_get_node_id(const struct LDKForwardNode *NONNULL_PTR this_ptr);
55000 export function ForwardNode_get_node_id(this_ptr: bigint): number {
55001 if(!isWasmInitialized) {
55002 throw new Error("initializeWasm() must be awaited first!");
55004 const nativeResponseValue = wasm.TS_ForwardNode_get_node_id(this_ptr);
55005 return nativeResponseValue;
55007 // void ForwardNode_set_node_id(struct LDKForwardNode *NONNULL_PTR this_ptr, struct LDKPublicKey val);
55009 export function ForwardNode_set_node_id(this_ptr: bigint, val: number): void {
55010 if(!isWasmInitialized) {
55011 throw new Error("initializeWasm() must be awaited first!");
55013 const nativeResponseValue = wasm.TS_ForwardNode_set_node_id(this_ptr, val);
55014 // debug statements here
55016 // uint64_t ForwardNode_get_htlc_maximum_msat(const struct LDKForwardNode *NONNULL_PTR this_ptr);
55018 export function ForwardNode_get_htlc_maximum_msat(this_ptr: bigint): bigint {
55019 if(!isWasmInitialized) {
55020 throw new Error("initializeWasm() must be awaited first!");
55022 const nativeResponseValue = wasm.TS_ForwardNode_get_htlc_maximum_msat(this_ptr);
55023 return nativeResponseValue;
55025 // void ForwardNode_set_htlc_maximum_msat(struct LDKForwardNode *NONNULL_PTR this_ptr, uint64_t val);
55027 export function ForwardNode_set_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
55028 if(!isWasmInitialized) {
55029 throw new Error("initializeWasm() must be awaited first!");
55031 const nativeResponseValue = wasm.TS_ForwardNode_set_htlc_maximum_msat(this_ptr, val);
55032 // debug statements here
55034 // MUST_USE_RES struct LDKForwardNode ForwardNode_new(struct LDKForwardTlvs tlvs_arg, struct LDKPublicKey node_id_arg, uint64_t htlc_maximum_msat_arg);
55036 export function ForwardNode_new(tlvs_arg: bigint, node_id_arg: number, htlc_maximum_msat_arg: bigint): bigint {
55037 if(!isWasmInitialized) {
55038 throw new Error("initializeWasm() must be awaited first!");
55040 const nativeResponseValue = wasm.TS_ForwardNode_new(tlvs_arg, node_id_arg, htlc_maximum_msat_arg);
55041 return nativeResponseValue;
55043 // uint64_t ForwardNode_clone_ptr(LDKForwardNode *NONNULL_PTR arg);
55045 export function ForwardNode_clone_ptr(arg: bigint): bigint {
55046 if(!isWasmInitialized) {
55047 throw new Error("initializeWasm() must be awaited first!");
55049 const nativeResponseValue = wasm.TS_ForwardNode_clone_ptr(arg);
55050 return nativeResponseValue;
55052 // struct LDKForwardNode ForwardNode_clone(const struct LDKForwardNode *NONNULL_PTR orig);
55054 export function ForwardNode_clone(orig: bigint): bigint {
55055 if(!isWasmInitialized) {
55056 throw new Error("initializeWasm() must be awaited first!");
55058 const nativeResponseValue = wasm.TS_ForwardNode_clone(orig);
55059 return nativeResponseValue;
55061 // void ForwardTlvs_free(struct LDKForwardTlvs this_obj);
55063 export function ForwardTlvs_free(this_obj: bigint): void {
55064 if(!isWasmInitialized) {
55065 throw new Error("initializeWasm() must be awaited first!");
55067 const nativeResponseValue = wasm.TS_ForwardTlvs_free(this_obj);
55068 // debug statements here
55070 // uint64_t ForwardTlvs_get_short_channel_id(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
55072 export function ForwardTlvs_get_short_channel_id(this_ptr: bigint): bigint {
55073 if(!isWasmInitialized) {
55074 throw new Error("initializeWasm() must be awaited first!");
55076 const nativeResponseValue = wasm.TS_ForwardTlvs_get_short_channel_id(this_ptr);
55077 return nativeResponseValue;
55079 // void ForwardTlvs_set_short_channel_id(struct LDKForwardTlvs *NONNULL_PTR this_ptr, uint64_t val);
55081 export function ForwardTlvs_set_short_channel_id(this_ptr: bigint, val: bigint): void {
55082 if(!isWasmInitialized) {
55083 throw new Error("initializeWasm() must be awaited first!");
55085 const nativeResponseValue = wasm.TS_ForwardTlvs_set_short_channel_id(this_ptr, val);
55086 // debug statements here
55088 // struct LDKPaymentRelay ForwardTlvs_get_payment_relay(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
55090 export function ForwardTlvs_get_payment_relay(this_ptr: bigint): bigint {
55091 if(!isWasmInitialized) {
55092 throw new Error("initializeWasm() must be awaited first!");
55094 const nativeResponseValue = wasm.TS_ForwardTlvs_get_payment_relay(this_ptr);
55095 return nativeResponseValue;
55097 // void ForwardTlvs_set_payment_relay(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKPaymentRelay val);
55099 export function ForwardTlvs_set_payment_relay(this_ptr: bigint, val: bigint): void {
55100 if(!isWasmInitialized) {
55101 throw new Error("initializeWasm() must be awaited first!");
55103 const nativeResponseValue = wasm.TS_ForwardTlvs_set_payment_relay(this_ptr, val);
55104 // debug statements here
55106 // struct LDKPaymentConstraints ForwardTlvs_get_payment_constraints(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
55108 export function ForwardTlvs_get_payment_constraints(this_ptr: bigint): bigint {
55109 if(!isWasmInitialized) {
55110 throw new Error("initializeWasm() must be awaited first!");
55112 const nativeResponseValue = wasm.TS_ForwardTlvs_get_payment_constraints(this_ptr);
55113 return nativeResponseValue;
55115 // void ForwardTlvs_set_payment_constraints(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKPaymentConstraints val);
55117 export function ForwardTlvs_set_payment_constraints(this_ptr: bigint, val: bigint): void {
55118 if(!isWasmInitialized) {
55119 throw new Error("initializeWasm() must be awaited first!");
55121 const nativeResponseValue = wasm.TS_ForwardTlvs_set_payment_constraints(this_ptr, val);
55122 // debug statements here
55124 // struct LDKBlindedHopFeatures ForwardTlvs_get_features(const struct LDKForwardTlvs *NONNULL_PTR this_ptr);
55126 export function ForwardTlvs_get_features(this_ptr: bigint): bigint {
55127 if(!isWasmInitialized) {
55128 throw new Error("initializeWasm() must be awaited first!");
55130 const nativeResponseValue = wasm.TS_ForwardTlvs_get_features(this_ptr);
55131 return nativeResponseValue;
55133 // void ForwardTlvs_set_features(struct LDKForwardTlvs *NONNULL_PTR this_ptr, struct LDKBlindedHopFeatures val);
55135 export function ForwardTlvs_set_features(this_ptr: bigint, val: bigint): void {
55136 if(!isWasmInitialized) {
55137 throw new Error("initializeWasm() must be awaited first!");
55139 const nativeResponseValue = wasm.TS_ForwardTlvs_set_features(this_ptr, val);
55140 // debug statements here
55142 // 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);
55144 export function ForwardTlvs_new(short_channel_id_arg: bigint, payment_relay_arg: bigint, payment_constraints_arg: bigint, features_arg: bigint): bigint {
55145 if(!isWasmInitialized) {
55146 throw new Error("initializeWasm() must be awaited first!");
55148 const nativeResponseValue = wasm.TS_ForwardTlvs_new(short_channel_id_arg, payment_relay_arg, payment_constraints_arg, features_arg);
55149 return nativeResponseValue;
55151 // uint64_t ForwardTlvs_clone_ptr(LDKForwardTlvs *NONNULL_PTR arg);
55153 export function ForwardTlvs_clone_ptr(arg: bigint): bigint {
55154 if(!isWasmInitialized) {
55155 throw new Error("initializeWasm() must be awaited first!");
55157 const nativeResponseValue = wasm.TS_ForwardTlvs_clone_ptr(arg);
55158 return nativeResponseValue;
55160 // struct LDKForwardTlvs ForwardTlvs_clone(const struct LDKForwardTlvs *NONNULL_PTR orig);
55162 export function ForwardTlvs_clone(orig: bigint): bigint {
55163 if(!isWasmInitialized) {
55164 throw new Error("initializeWasm() must be awaited first!");
55166 const nativeResponseValue = wasm.TS_ForwardTlvs_clone(orig);
55167 return nativeResponseValue;
55169 // void ReceiveTlvs_free(struct LDKReceiveTlvs this_obj);
55171 export function ReceiveTlvs_free(this_obj: bigint): void {
55172 if(!isWasmInitialized) {
55173 throw new Error("initializeWasm() must be awaited first!");
55175 const nativeResponseValue = wasm.TS_ReceiveTlvs_free(this_obj);
55176 // debug statements here
55178 // const uint8_t (*ReceiveTlvs_get_payment_secret(const struct LDKReceiveTlvs *NONNULL_PTR this_ptr))[32];
55180 export function ReceiveTlvs_get_payment_secret(this_ptr: bigint): number {
55181 if(!isWasmInitialized) {
55182 throw new Error("initializeWasm() must be awaited first!");
55184 const nativeResponseValue = wasm.TS_ReceiveTlvs_get_payment_secret(this_ptr);
55185 return nativeResponseValue;
55187 // void ReceiveTlvs_set_payment_secret(struct LDKReceiveTlvs *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
55189 export function ReceiveTlvs_set_payment_secret(this_ptr: bigint, val: number): void {
55190 if(!isWasmInitialized) {
55191 throw new Error("initializeWasm() must be awaited first!");
55193 const nativeResponseValue = wasm.TS_ReceiveTlvs_set_payment_secret(this_ptr, val);
55194 // debug statements here
55196 // struct LDKPaymentConstraints ReceiveTlvs_get_payment_constraints(const struct LDKReceiveTlvs *NONNULL_PTR this_ptr);
55198 export function ReceiveTlvs_get_payment_constraints(this_ptr: bigint): bigint {
55199 if(!isWasmInitialized) {
55200 throw new Error("initializeWasm() must be awaited first!");
55202 const nativeResponseValue = wasm.TS_ReceiveTlvs_get_payment_constraints(this_ptr);
55203 return nativeResponseValue;
55205 // void ReceiveTlvs_set_payment_constraints(struct LDKReceiveTlvs *NONNULL_PTR this_ptr, struct LDKPaymentConstraints val);
55207 export function ReceiveTlvs_set_payment_constraints(this_ptr: bigint, val: bigint): void {
55208 if(!isWasmInitialized) {
55209 throw new Error("initializeWasm() must be awaited first!");
55211 const nativeResponseValue = wasm.TS_ReceiveTlvs_set_payment_constraints(this_ptr, val);
55212 // debug statements here
55214 // MUST_USE_RES struct LDKReceiveTlvs ReceiveTlvs_new(struct LDKThirtyTwoBytes payment_secret_arg, struct LDKPaymentConstraints payment_constraints_arg);
55216 export function ReceiveTlvs_new(payment_secret_arg: number, payment_constraints_arg: bigint): bigint {
55217 if(!isWasmInitialized) {
55218 throw new Error("initializeWasm() must be awaited first!");
55220 const nativeResponseValue = wasm.TS_ReceiveTlvs_new(payment_secret_arg, payment_constraints_arg);
55221 return nativeResponseValue;
55223 // uint64_t ReceiveTlvs_clone_ptr(LDKReceiveTlvs *NONNULL_PTR arg);
55225 export function ReceiveTlvs_clone_ptr(arg: bigint): bigint {
55226 if(!isWasmInitialized) {
55227 throw new Error("initializeWasm() must be awaited first!");
55229 const nativeResponseValue = wasm.TS_ReceiveTlvs_clone_ptr(arg);
55230 return nativeResponseValue;
55232 // struct LDKReceiveTlvs ReceiveTlvs_clone(const struct LDKReceiveTlvs *NONNULL_PTR orig);
55234 export function ReceiveTlvs_clone(orig: bigint): bigint {
55235 if(!isWasmInitialized) {
55236 throw new Error("initializeWasm() must be awaited first!");
55238 const nativeResponseValue = wasm.TS_ReceiveTlvs_clone(orig);
55239 return nativeResponseValue;
55241 // void PaymentRelay_free(struct LDKPaymentRelay this_obj);
55243 export function PaymentRelay_free(this_obj: bigint): void {
55244 if(!isWasmInitialized) {
55245 throw new Error("initializeWasm() must be awaited first!");
55247 const nativeResponseValue = wasm.TS_PaymentRelay_free(this_obj);
55248 // debug statements here
55250 // uint16_t PaymentRelay_get_cltv_expiry_delta(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
55252 export function PaymentRelay_get_cltv_expiry_delta(this_ptr: bigint): number {
55253 if(!isWasmInitialized) {
55254 throw new Error("initializeWasm() must be awaited first!");
55256 const nativeResponseValue = wasm.TS_PaymentRelay_get_cltv_expiry_delta(this_ptr);
55257 return nativeResponseValue;
55259 // void PaymentRelay_set_cltv_expiry_delta(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint16_t val);
55261 export function PaymentRelay_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
55262 if(!isWasmInitialized) {
55263 throw new Error("initializeWasm() must be awaited first!");
55265 const nativeResponseValue = wasm.TS_PaymentRelay_set_cltv_expiry_delta(this_ptr, val);
55266 // debug statements here
55268 // uint32_t PaymentRelay_get_fee_proportional_millionths(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
55270 export function PaymentRelay_get_fee_proportional_millionths(this_ptr: bigint): number {
55271 if(!isWasmInitialized) {
55272 throw new Error("initializeWasm() must be awaited first!");
55274 const nativeResponseValue = wasm.TS_PaymentRelay_get_fee_proportional_millionths(this_ptr);
55275 return nativeResponseValue;
55277 // void PaymentRelay_set_fee_proportional_millionths(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint32_t val);
55279 export function PaymentRelay_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
55280 if(!isWasmInitialized) {
55281 throw new Error("initializeWasm() must be awaited first!");
55283 const nativeResponseValue = wasm.TS_PaymentRelay_set_fee_proportional_millionths(this_ptr, val);
55284 // debug statements here
55286 // uint32_t PaymentRelay_get_fee_base_msat(const struct LDKPaymentRelay *NONNULL_PTR this_ptr);
55288 export function PaymentRelay_get_fee_base_msat(this_ptr: bigint): number {
55289 if(!isWasmInitialized) {
55290 throw new Error("initializeWasm() must be awaited first!");
55292 const nativeResponseValue = wasm.TS_PaymentRelay_get_fee_base_msat(this_ptr);
55293 return nativeResponseValue;
55295 // void PaymentRelay_set_fee_base_msat(struct LDKPaymentRelay *NONNULL_PTR this_ptr, uint32_t val);
55297 export function PaymentRelay_set_fee_base_msat(this_ptr: bigint, val: number): void {
55298 if(!isWasmInitialized) {
55299 throw new Error("initializeWasm() must be awaited first!");
55301 const nativeResponseValue = wasm.TS_PaymentRelay_set_fee_base_msat(this_ptr, val);
55302 // debug statements here
55304 // 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);
55306 export function PaymentRelay_new(cltv_expiry_delta_arg: number, fee_proportional_millionths_arg: number, fee_base_msat_arg: number): bigint {
55307 if(!isWasmInitialized) {
55308 throw new Error("initializeWasm() must be awaited first!");
55310 const nativeResponseValue = wasm.TS_PaymentRelay_new(cltv_expiry_delta_arg, fee_proportional_millionths_arg, fee_base_msat_arg);
55311 return nativeResponseValue;
55313 // uint64_t PaymentRelay_clone_ptr(LDKPaymentRelay *NONNULL_PTR arg);
55315 export function PaymentRelay_clone_ptr(arg: bigint): bigint {
55316 if(!isWasmInitialized) {
55317 throw new Error("initializeWasm() must be awaited first!");
55319 const nativeResponseValue = wasm.TS_PaymentRelay_clone_ptr(arg);
55320 return nativeResponseValue;
55322 // struct LDKPaymentRelay PaymentRelay_clone(const struct LDKPaymentRelay *NONNULL_PTR orig);
55324 export function PaymentRelay_clone(orig: bigint): bigint {
55325 if(!isWasmInitialized) {
55326 throw new Error("initializeWasm() must be awaited first!");
55328 const nativeResponseValue = wasm.TS_PaymentRelay_clone(orig);
55329 return nativeResponseValue;
55331 // void PaymentConstraints_free(struct LDKPaymentConstraints this_obj);
55333 export function PaymentConstraints_free(this_obj: bigint): void {
55334 if(!isWasmInitialized) {
55335 throw new Error("initializeWasm() must be awaited first!");
55337 const nativeResponseValue = wasm.TS_PaymentConstraints_free(this_obj);
55338 // debug statements here
55340 // uint32_t PaymentConstraints_get_max_cltv_expiry(const struct LDKPaymentConstraints *NONNULL_PTR this_ptr);
55342 export function PaymentConstraints_get_max_cltv_expiry(this_ptr: bigint): number {
55343 if(!isWasmInitialized) {
55344 throw new Error("initializeWasm() must be awaited first!");
55346 const nativeResponseValue = wasm.TS_PaymentConstraints_get_max_cltv_expiry(this_ptr);
55347 return nativeResponseValue;
55349 // void PaymentConstraints_set_max_cltv_expiry(struct LDKPaymentConstraints *NONNULL_PTR this_ptr, uint32_t val);
55351 export function PaymentConstraints_set_max_cltv_expiry(this_ptr: bigint, val: number): void {
55352 if(!isWasmInitialized) {
55353 throw new Error("initializeWasm() must be awaited first!");
55355 const nativeResponseValue = wasm.TS_PaymentConstraints_set_max_cltv_expiry(this_ptr, val);
55356 // debug statements here
55358 // uint64_t PaymentConstraints_get_htlc_minimum_msat(const struct LDKPaymentConstraints *NONNULL_PTR this_ptr);
55360 export function PaymentConstraints_get_htlc_minimum_msat(this_ptr: bigint): bigint {
55361 if(!isWasmInitialized) {
55362 throw new Error("initializeWasm() must be awaited first!");
55364 const nativeResponseValue = wasm.TS_PaymentConstraints_get_htlc_minimum_msat(this_ptr);
55365 return nativeResponseValue;
55367 // void PaymentConstraints_set_htlc_minimum_msat(struct LDKPaymentConstraints *NONNULL_PTR this_ptr, uint64_t val);
55369 export function PaymentConstraints_set_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
55370 if(!isWasmInitialized) {
55371 throw new Error("initializeWasm() must be awaited first!");
55373 const nativeResponseValue = wasm.TS_PaymentConstraints_set_htlc_minimum_msat(this_ptr, val);
55374 // debug statements here
55376 // MUST_USE_RES struct LDKPaymentConstraints PaymentConstraints_new(uint32_t max_cltv_expiry_arg, uint64_t htlc_minimum_msat_arg);
55378 export function PaymentConstraints_new(max_cltv_expiry_arg: number, htlc_minimum_msat_arg: bigint): bigint {
55379 if(!isWasmInitialized) {
55380 throw new Error("initializeWasm() must be awaited first!");
55382 const nativeResponseValue = wasm.TS_PaymentConstraints_new(max_cltv_expiry_arg, htlc_minimum_msat_arg);
55383 return nativeResponseValue;
55385 // uint64_t PaymentConstraints_clone_ptr(LDKPaymentConstraints *NONNULL_PTR arg);
55387 export function PaymentConstraints_clone_ptr(arg: bigint): bigint {
55388 if(!isWasmInitialized) {
55389 throw new Error("initializeWasm() must be awaited first!");
55391 const nativeResponseValue = wasm.TS_PaymentConstraints_clone_ptr(arg);
55392 return nativeResponseValue;
55394 // struct LDKPaymentConstraints PaymentConstraints_clone(const struct LDKPaymentConstraints *NONNULL_PTR orig);
55396 export function PaymentConstraints_clone(orig: bigint): bigint {
55397 if(!isWasmInitialized) {
55398 throw new Error("initializeWasm() must be awaited first!");
55400 const nativeResponseValue = wasm.TS_PaymentConstraints_clone(orig);
55401 return nativeResponseValue;
55403 // struct LDKCVec_u8Z ForwardTlvs_write(const struct LDKForwardTlvs *NONNULL_PTR obj);
55405 export function ForwardTlvs_write(obj: bigint): number {
55406 if(!isWasmInitialized) {
55407 throw new Error("initializeWasm() must be awaited first!");
55409 const nativeResponseValue = wasm.TS_ForwardTlvs_write(obj);
55410 return nativeResponseValue;
55412 // struct LDKCVec_u8Z ReceiveTlvs_write(const struct LDKReceiveTlvs *NONNULL_PTR obj);
55414 export function ReceiveTlvs_write(obj: bigint): number {
55415 if(!isWasmInitialized) {
55416 throw new Error("initializeWasm() must be awaited first!");
55418 const nativeResponseValue = wasm.TS_ReceiveTlvs_write(obj);
55419 return nativeResponseValue;
55421 // struct LDKCVec_u8Z PaymentRelay_write(const struct LDKPaymentRelay *NONNULL_PTR obj);
55423 export function PaymentRelay_write(obj: bigint): number {
55424 if(!isWasmInitialized) {
55425 throw new Error("initializeWasm() must be awaited first!");
55427 const nativeResponseValue = wasm.TS_PaymentRelay_write(obj);
55428 return nativeResponseValue;
55430 // struct LDKCResult_PaymentRelayDecodeErrorZ PaymentRelay_read(struct LDKu8slice ser);
55432 export function PaymentRelay_read(ser: number): bigint {
55433 if(!isWasmInitialized) {
55434 throw new Error("initializeWasm() must be awaited first!");
55436 const nativeResponseValue = wasm.TS_PaymentRelay_read(ser);
55437 return nativeResponseValue;
55439 // struct LDKCVec_u8Z PaymentConstraints_write(const struct LDKPaymentConstraints *NONNULL_PTR obj);
55441 export function PaymentConstraints_write(obj: bigint): number {
55442 if(!isWasmInitialized) {
55443 throw new Error("initializeWasm() must be awaited first!");
55445 const nativeResponseValue = wasm.TS_PaymentConstraints_write(obj);
55446 return nativeResponseValue;
55448 // struct LDKCResult_PaymentConstraintsDecodeErrorZ PaymentConstraints_read(struct LDKu8slice ser);
55450 export function PaymentConstraints_read(ser: number): bigint {
55451 if(!isWasmInitialized) {
55452 throw new Error("initializeWasm() must be awaited first!");
55454 const nativeResponseValue = wasm.TS_PaymentConstraints_read(ser);
55455 return nativeResponseValue;
55457 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
55459 export function PaymentPurpose_free(this_ptr: bigint): void {
55460 if(!isWasmInitialized) {
55461 throw new Error("initializeWasm() must be awaited first!");
55463 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
55464 // debug statements here
55466 // uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
55468 export function PaymentPurpose_clone_ptr(arg: bigint): bigint {
55469 if(!isWasmInitialized) {
55470 throw new Error("initializeWasm() must be awaited first!");
55472 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
55473 return nativeResponseValue;
55475 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
55477 export function PaymentPurpose_clone(orig: bigint): bigint {
55478 if(!isWasmInitialized) {
55479 throw new Error("initializeWasm() must be awaited first!");
55481 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
55482 return nativeResponseValue;
55484 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKThirtyTwoBytes payment_secret);
55486 export function PaymentPurpose_invoice_payment(payment_preimage: bigint, payment_secret: number): bigint {
55487 if(!isWasmInitialized) {
55488 throw new Error("initializeWasm() must be awaited first!");
55490 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
55491 return nativeResponseValue;
55493 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
55495 export function PaymentPurpose_spontaneous_payment(a: number): bigint {
55496 if(!isWasmInitialized) {
55497 throw new Error("initializeWasm() must be awaited first!");
55499 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
55500 return nativeResponseValue;
55502 // bool PaymentPurpose_eq(const struct LDKPaymentPurpose *NONNULL_PTR a, const struct LDKPaymentPurpose *NONNULL_PTR b);
55504 export function PaymentPurpose_eq(a: bigint, b: bigint): boolean {
55505 if(!isWasmInitialized) {
55506 throw new Error("initializeWasm() must be awaited first!");
55508 const nativeResponseValue = wasm.TS_PaymentPurpose_eq(a, b);
55509 return nativeResponseValue;
55511 // MUST_USE_RES struct LDKCOption_ThirtyTwoBytesZ PaymentPurpose_preimage(const struct LDKPaymentPurpose *NONNULL_PTR this_arg);
55513 export function PaymentPurpose_preimage(this_arg: bigint): bigint {
55514 if(!isWasmInitialized) {
55515 throw new Error("initializeWasm() must be awaited first!");
55517 const nativeResponseValue = wasm.TS_PaymentPurpose_preimage(this_arg);
55518 return nativeResponseValue;
55520 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
55522 export function PaymentPurpose_write(obj: bigint): number {
55523 if(!isWasmInitialized) {
55524 throw new Error("initializeWasm() must be awaited first!");
55526 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
55527 return nativeResponseValue;
55529 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
55531 export function PaymentPurpose_read(ser: number): bigint {
55532 if(!isWasmInitialized) {
55533 throw new Error("initializeWasm() must be awaited first!");
55535 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
55536 return nativeResponseValue;
55538 // void ClaimedHTLC_free(struct LDKClaimedHTLC this_obj);
55540 export function ClaimedHTLC_free(this_obj: bigint): void {
55541 if(!isWasmInitialized) {
55542 throw new Error("initializeWasm() must be awaited first!");
55544 const nativeResponseValue = wasm.TS_ClaimedHTLC_free(this_obj);
55545 // debug statements here
55547 // const uint8_t (*ClaimedHTLC_get_channel_id(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr))[32];
55549 export function ClaimedHTLC_get_channel_id(this_ptr: bigint): number {
55550 if(!isWasmInitialized) {
55551 throw new Error("initializeWasm() must be awaited first!");
55553 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_channel_id(this_ptr);
55554 return nativeResponseValue;
55556 // void ClaimedHTLC_set_channel_id(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
55558 export function ClaimedHTLC_set_channel_id(this_ptr: bigint, val: number): void {
55559 if(!isWasmInitialized) {
55560 throw new Error("initializeWasm() must be awaited first!");
55562 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_channel_id(this_ptr, val);
55563 // debug statements here
55565 // struct LDKU128 ClaimedHTLC_get_user_channel_id(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
55567 export function ClaimedHTLC_get_user_channel_id(this_ptr: bigint): number {
55568 if(!isWasmInitialized) {
55569 throw new Error("initializeWasm() must be awaited first!");
55571 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_user_channel_id(this_ptr);
55572 return nativeResponseValue;
55574 // void ClaimedHTLC_set_user_channel_id(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, struct LDKU128 val);
55576 export function ClaimedHTLC_set_user_channel_id(this_ptr: bigint, val: number): void {
55577 if(!isWasmInitialized) {
55578 throw new Error("initializeWasm() must be awaited first!");
55580 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_user_channel_id(this_ptr, val);
55581 // debug statements here
55583 // uint32_t ClaimedHTLC_get_cltv_expiry(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
55585 export function ClaimedHTLC_get_cltv_expiry(this_ptr: bigint): number {
55586 if(!isWasmInitialized) {
55587 throw new Error("initializeWasm() must be awaited first!");
55589 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_cltv_expiry(this_ptr);
55590 return nativeResponseValue;
55592 // void ClaimedHTLC_set_cltv_expiry(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, uint32_t val);
55594 export function ClaimedHTLC_set_cltv_expiry(this_ptr: bigint, val: number): void {
55595 if(!isWasmInitialized) {
55596 throw new Error("initializeWasm() must be awaited first!");
55598 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_cltv_expiry(this_ptr, val);
55599 // debug statements here
55601 // uint64_t ClaimedHTLC_get_value_msat(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
55603 export function ClaimedHTLC_get_value_msat(this_ptr: bigint): bigint {
55604 if(!isWasmInitialized) {
55605 throw new Error("initializeWasm() must be awaited first!");
55607 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_value_msat(this_ptr);
55608 return nativeResponseValue;
55610 // void ClaimedHTLC_set_value_msat(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, uint64_t val);
55612 export function ClaimedHTLC_set_value_msat(this_ptr: bigint, val: bigint): void {
55613 if(!isWasmInitialized) {
55614 throw new Error("initializeWasm() must be awaited first!");
55616 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_value_msat(this_ptr, val);
55617 // debug statements here
55619 // uint64_t ClaimedHTLC_get_counterparty_skimmed_fee_msat(const struct LDKClaimedHTLC *NONNULL_PTR this_ptr);
55621 export function ClaimedHTLC_get_counterparty_skimmed_fee_msat(this_ptr: bigint): bigint {
55622 if(!isWasmInitialized) {
55623 throw new Error("initializeWasm() must be awaited first!");
55625 const nativeResponseValue = wasm.TS_ClaimedHTLC_get_counterparty_skimmed_fee_msat(this_ptr);
55626 return nativeResponseValue;
55628 // void ClaimedHTLC_set_counterparty_skimmed_fee_msat(struct LDKClaimedHTLC *NONNULL_PTR this_ptr, uint64_t val);
55630 export function ClaimedHTLC_set_counterparty_skimmed_fee_msat(this_ptr: bigint, val: bigint): void {
55631 if(!isWasmInitialized) {
55632 throw new Error("initializeWasm() must be awaited first!");
55634 const nativeResponseValue = wasm.TS_ClaimedHTLC_set_counterparty_skimmed_fee_msat(this_ptr, val);
55635 // debug statements here
55637 // 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, uint64_t counterparty_skimmed_fee_msat_arg);
55639 export function ClaimedHTLC_new(channel_id_arg: number, user_channel_id_arg: number, cltv_expiry_arg: number, value_msat_arg: bigint, counterparty_skimmed_fee_msat_arg: bigint): bigint {
55640 if(!isWasmInitialized) {
55641 throw new Error("initializeWasm() must be awaited first!");
55643 const nativeResponseValue = wasm.TS_ClaimedHTLC_new(channel_id_arg, user_channel_id_arg, cltv_expiry_arg, value_msat_arg, counterparty_skimmed_fee_msat_arg);
55644 return nativeResponseValue;
55646 // uint64_t ClaimedHTLC_clone_ptr(LDKClaimedHTLC *NONNULL_PTR arg);
55648 export function ClaimedHTLC_clone_ptr(arg: bigint): bigint {
55649 if(!isWasmInitialized) {
55650 throw new Error("initializeWasm() must be awaited first!");
55652 const nativeResponseValue = wasm.TS_ClaimedHTLC_clone_ptr(arg);
55653 return nativeResponseValue;
55655 // struct LDKClaimedHTLC ClaimedHTLC_clone(const struct LDKClaimedHTLC *NONNULL_PTR orig);
55657 export function ClaimedHTLC_clone(orig: bigint): bigint {
55658 if(!isWasmInitialized) {
55659 throw new Error("initializeWasm() must be awaited first!");
55661 const nativeResponseValue = wasm.TS_ClaimedHTLC_clone(orig);
55662 return nativeResponseValue;
55664 // bool ClaimedHTLC_eq(const struct LDKClaimedHTLC *NONNULL_PTR a, const struct LDKClaimedHTLC *NONNULL_PTR b);
55666 export function ClaimedHTLC_eq(a: bigint, b: bigint): boolean {
55667 if(!isWasmInitialized) {
55668 throw new Error("initializeWasm() must be awaited first!");
55670 const nativeResponseValue = wasm.TS_ClaimedHTLC_eq(a, b);
55671 return nativeResponseValue;
55673 // struct LDKCVec_u8Z ClaimedHTLC_write(const struct LDKClaimedHTLC *NONNULL_PTR obj);
55675 export function ClaimedHTLC_write(obj: bigint): number {
55676 if(!isWasmInitialized) {
55677 throw new Error("initializeWasm() must be awaited first!");
55679 const nativeResponseValue = wasm.TS_ClaimedHTLC_write(obj);
55680 return nativeResponseValue;
55682 // struct LDKCResult_ClaimedHTLCDecodeErrorZ ClaimedHTLC_read(struct LDKu8slice ser);
55684 export function ClaimedHTLC_read(ser: number): bigint {
55685 if(!isWasmInitialized) {
55686 throw new Error("initializeWasm() must be awaited first!");
55688 const nativeResponseValue = wasm.TS_ClaimedHTLC_read(ser);
55689 return nativeResponseValue;
55691 // void PathFailure_free(struct LDKPathFailure this_ptr);
55693 export function PathFailure_free(this_ptr: bigint): void {
55694 if(!isWasmInitialized) {
55695 throw new Error("initializeWasm() must be awaited first!");
55697 const nativeResponseValue = wasm.TS_PathFailure_free(this_ptr);
55698 // debug statements here
55700 // uint64_t PathFailure_clone_ptr(LDKPathFailure *NONNULL_PTR arg);
55702 export function PathFailure_clone_ptr(arg: bigint): bigint {
55703 if(!isWasmInitialized) {
55704 throw new Error("initializeWasm() must be awaited first!");
55706 const nativeResponseValue = wasm.TS_PathFailure_clone_ptr(arg);
55707 return nativeResponseValue;
55709 // struct LDKPathFailure PathFailure_clone(const struct LDKPathFailure *NONNULL_PTR orig);
55711 export function PathFailure_clone(orig: bigint): bigint {
55712 if(!isWasmInitialized) {
55713 throw new Error("initializeWasm() must be awaited first!");
55715 const nativeResponseValue = wasm.TS_PathFailure_clone(orig);
55716 return nativeResponseValue;
55718 // struct LDKPathFailure PathFailure_initial_send(struct LDKAPIError err);
55720 export function PathFailure_initial_send(err: bigint): bigint {
55721 if(!isWasmInitialized) {
55722 throw new Error("initializeWasm() must be awaited first!");
55724 const nativeResponseValue = wasm.TS_PathFailure_initial_send(err);
55725 return nativeResponseValue;
55727 // struct LDKPathFailure PathFailure_on_path(struct LDKCOption_NetworkUpdateZ network_update);
55729 export function PathFailure_on_path(network_update: bigint): bigint {
55730 if(!isWasmInitialized) {
55731 throw new Error("initializeWasm() must be awaited first!");
55733 const nativeResponseValue = wasm.TS_PathFailure_on_path(network_update);
55734 return nativeResponseValue;
55736 // bool PathFailure_eq(const struct LDKPathFailure *NONNULL_PTR a, const struct LDKPathFailure *NONNULL_PTR b);
55738 export function PathFailure_eq(a: bigint, b: bigint): boolean {
55739 if(!isWasmInitialized) {
55740 throw new Error("initializeWasm() must be awaited first!");
55742 const nativeResponseValue = wasm.TS_PathFailure_eq(a, b);
55743 return nativeResponseValue;
55745 // struct LDKCVec_u8Z PathFailure_write(const struct LDKPathFailure *NONNULL_PTR obj);
55747 export function PathFailure_write(obj: bigint): number {
55748 if(!isWasmInitialized) {
55749 throw new Error("initializeWasm() must be awaited first!");
55751 const nativeResponseValue = wasm.TS_PathFailure_write(obj);
55752 return nativeResponseValue;
55754 // struct LDKCResult_COption_PathFailureZDecodeErrorZ PathFailure_read(struct LDKu8slice ser);
55756 export function PathFailure_read(ser: number): bigint {
55757 if(!isWasmInitialized) {
55758 throw new Error("initializeWasm() must be awaited first!");
55760 const nativeResponseValue = wasm.TS_PathFailure_read(ser);
55761 return nativeResponseValue;
55763 // void ClosureReason_free(struct LDKClosureReason this_ptr);
55765 export function ClosureReason_free(this_ptr: bigint): void {
55766 if(!isWasmInitialized) {
55767 throw new Error("initializeWasm() must be awaited first!");
55769 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
55770 // debug statements here
55772 // uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
55774 export function ClosureReason_clone_ptr(arg: bigint): bigint {
55775 if(!isWasmInitialized) {
55776 throw new Error("initializeWasm() must be awaited first!");
55778 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
55779 return nativeResponseValue;
55781 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
55783 export function ClosureReason_clone(orig: bigint): bigint {
55784 if(!isWasmInitialized) {
55785 throw new Error("initializeWasm() must be awaited first!");
55787 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
55788 return nativeResponseValue;
55790 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKUntrustedString peer_msg);
55792 export function ClosureReason_counterparty_force_closed(peer_msg: bigint): bigint {
55793 if(!isWasmInitialized) {
55794 throw new Error("initializeWasm() must be awaited first!");
55796 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
55797 return nativeResponseValue;
55799 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
55801 export function ClosureReason_holder_force_closed(): bigint {
55802 if(!isWasmInitialized) {
55803 throw new Error("initializeWasm() must be awaited first!");
55805 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
55806 return nativeResponseValue;
55808 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
55810 export function ClosureReason_cooperative_closure(): bigint {
55811 if(!isWasmInitialized) {
55812 throw new Error("initializeWasm() must be awaited first!");
55814 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
55815 return nativeResponseValue;
55817 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
55819 export function ClosureReason_commitment_tx_confirmed(): bigint {
55820 if(!isWasmInitialized) {
55821 throw new Error("initializeWasm() must be awaited first!");
55823 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
55824 return nativeResponseValue;
55826 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
55828 export function ClosureReason_funding_timed_out(): bigint {
55829 if(!isWasmInitialized) {
55830 throw new Error("initializeWasm() must be awaited first!");
55832 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
55833 return nativeResponseValue;
55835 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
55837 export function ClosureReason_processing_error(err: number): bigint {
55838 if(!isWasmInitialized) {
55839 throw new Error("initializeWasm() must be awaited first!");
55841 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
55842 return nativeResponseValue;
55844 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
55846 export function ClosureReason_disconnected_peer(): bigint {
55847 if(!isWasmInitialized) {
55848 throw new Error("initializeWasm() must be awaited first!");
55850 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
55851 return nativeResponseValue;
55853 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
55855 export function ClosureReason_outdated_channel_manager(): bigint {
55856 if(!isWasmInitialized) {
55857 throw new Error("initializeWasm() must be awaited first!");
55859 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
55860 return nativeResponseValue;
55862 // struct LDKClosureReason ClosureReason_counterparty_coop_closed_unfunded_channel(void);
55864 export function ClosureReason_counterparty_coop_closed_unfunded_channel(): bigint {
55865 if(!isWasmInitialized) {
55866 throw new Error("initializeWasm() must be awaited first!");
55868 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_coop_closed_unfunded_channel();
55869 return nativeResponseValue;
55871 // struct LDKClosureReason ClosureReason_funding_batch_closure(void);
55873 export function ClosureReason_funding_batch_closure(): bigint {
55874 if(!isWasmInitialized) {
55875 throw new Error("initializeWasm() must be awaited first!");
55877 const nativeResponseValue = wasm.TS_ClosureReason_funding_batch_closure();
55878 return nativeResponseValue;
55880 // bool ClosureReason_eq(const struct LDKClosureReason *NONNULL_PTR a, const struct LDKClosureReason *NONNULL_PTR b);
55882 export function ClosureReason_eq(a: bigint, b: bigint): boolean {
55883 if(!isWasmInitialized) {
55884 throw new Error("initializeWasm() must be awaited first!");
55886 const nativeResponseValue = wasm.TS_ClosureReason_eq(a, b);
55887 return nativeResponseValue;
55889 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
55891 export function ClosureReason_write(obj: bigint): number {
55892 if(!isWasmInitialized) {
55893 throw new Error("initializeWasm() must be awaited first!");
55895 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
55896 return nativeResponseValue;
55898 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
55900 export function ClosureReason_read(ser: number): bigint {
55901 if(!isWasmInitialized) {
55902 throw new Error("initializeWasm() must be awaited first!");
55904 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
55905 return nativeResponseValue;
55907 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
55909 export function HTLCDestination_free(this_ptr: bigint): void {
55910 if(!isWasmInitialized) {
55911 throw new Error("initializeWasm() must be awaited first!");
55913 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
55914 // debug statements here
55916 // uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
55918 export function HTLCDestination_clone_ptr(arg: bigint): bigint {
55919 if(!isWasmInitialized) {
55920 throw new Error("initializeWasm() must be awaited first!");
55922 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
55923 return nativeResponseValue;
55925 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
55927 export function HTLCDestination_clone(orig: bigint): bigint {
55928 if(!isWasmInitialized) {
55929 throw new Error("initializeWasm() must be awaited first!");
55931 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
55932 return nativeResponseValue;
55934 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
55936 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): bigint {
55937 if(!isWasmInitialized) {
55938 throw new Error("initializeWasm() must be awaited first!");
55940 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
55941 return nativeResponseValue;
55943 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
55945 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): bigint {
55946 if(!isWasmInitialized) {
55947 throw new Error("initializeWasm() must be awaited first!");
55949 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
55950 return nativeResponseValue;
55952 // struct LDKHTLCDestination HTLCDestination_invalid_forward(uint64_t requested_forward_scid);
55954 export function HTLCDestination_invalid_forward(requested_forward_scid: bigint): bigint {
55955 if(!isWasmInitialized) {
55956 throw new Error("initializeWasm() must be awaited first!");
55958 const nativeResponseValue = wasm.TS_HTLCDestination_invalid_forward(requested_forward_scid);
55959 return nativeResponseValue;
55961 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
55963 export function HTLCDestination_failed_payment(payment_hash: number): bigint {
55964 if(!isWasmInitialized) {
55965 throw new Error("initializeWasm() must be awaited first!");
55967 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
55968 return nativeResponseValue;
55970 // bool HTLCDestination_eq(const struct LDKHTLCDestination *NONNULL_PTR a, const struct LDKHTLCDestination *NONNULL_PTR b);
55972 export function HTLCDestination_eq(a: bigint, b: bigint): boolean {
55973 if(!isWasmInitialized) {
55974 throw new Error("initializeWasm() must be awaited first!");
55976 const nativeResponseValue = wasm.TS_HTLCDestination_eq(a, b);
55977 return nativeResponseValue;
55979 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
55981 export function HTLCDestination_write(obj: bigint): number {
55982 if(!isWasmInitialized) {
55983 throw new Error("initializeWasm() must be awaited first!");
55985 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
55986 return nativeResponseValue;
55988 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
55990 export function HTLCDestination_read(ser: number): bigint {
55991 if(!isWasmInitialized) {
55992 throw new Error("initializeWasm() must be awaited first!");
55994 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
55995 return nativeResponseValue;
55997 // enum LDKPaymentFailureReason PaymentFailureReason_clone(const enum LDKPaymentFailureReason *NONNULL_PTR orig);
55999 export function PaymentFailureReason_clone(orig: bigint): PaymentFailureReason {
56000 if(!isWasmInitialized) {
56001 throw new Error("initializeWasm() must be awaited first!");
56003 const nativeResponseValue = wasm.TS_PaymentFailureReason_clone(orig);
56004 return nativeResponseValue;
56006 // enum LDKPaymentFailureReason PaymentFailureReason_recipient_rejected(void);
56008 export function PaymentFailureReason_recipient_rejected(): PaymentFailureReason {
56009 if(!isWasmInitialized) {
56010 throw new Error("initializeWasm() must be awaited first!");
56012 const nativeResponseValue = wasm.TS_PaymentFailureReason_recipient_rejected();
56013 return nativeResponseValue;
56015 // enum LDKPaymentFailureReason PaymentFailureReason_user_abandoned(void);
56017 export function PaymentFailureReason_user_abandoned(): PaymentFailureReason {
56018 if(!isWasmInitialized) {
56019 throw new Error("initializeWasm() must be awaited first!");
56021 const nativeResponseValue = wasm.TS_PaymentFailureReason_user_abandoned();
56022 return nativeResponseValue;
56024 // enum LDKPaymentFailureReason PaymentFailureReason_retries_exhausted(void);
56026 export function PaymentFailureReason_retries_exhausted(): PaymentFailureReason {
56027 if(!isWasmInitialized) {
56028 throw new Error("initializeWasm() must be awaited first!");
56030 const nativeResponseValue = wasm.TS_PaymentFailureReason_retries_exhausted();
56031 return nativeResponseValue;
56033 // enum LDKPaymentFailureReason PaymentFailureReason_payment_expired(void);
56035 export function PaymentFailureReason_payment_expired(): PaymentFailureReason {
56036 if(!isWasmInitialized) {
56037 throw new Error("initializeWasm() must be awaited first!");
56039 const nativeResponseValue = wasm.TS_PaymentFailureReason_payment_expired();
56040 return nativeResponseValue;
56042 // enum LDKPaymentFailureReason PaymentFailureReason_route_not_found(void);
56044 export function PaymentFailureReason_route_not_found(): PaymentFailureReason {
56045 if(!isWasmInitialized) {
56046 throw new Error("initializeWasm() must be awaited first!");
56048 const nativeResponseValue = wasm.TS_PaymentFailureReason_route_not_found();
56049 return nativeResponseValue;
56051 // enum LDKPaymentFailureReason PaymentFailureReason_unexpected_error(void);
56053 export function PaymentFailureReason_unexpected_error(): PaymentFailureReason {
56054 if(!isWasmInitialized) {
56055 throw new Error("initializeWasm() must be awaited first!");
56057 const nativeResponseValue = wasm.TS_PaymentFailureReason_unexpected_error();
56058 return nativeResponseValue;
56060 // bool PaymentFailureReason_eq(const enum LDKPaymentFailureReason *NONNULL_PTR a, const enum LDKPaymentFailureReason *NONNULL_PTR b);
56062 export function PaymentFailureReason_eq(a: bigint, b: bigint): boolean {
56063 if(!isWasmInitialized) {
56064 throw new Error("initializeWasm() must be awaited first!");
56066 const nativeResponseValue = wasm.TS_PaymentFailureReason_eq(a, b);
56067 return nativeResponseValue;
56069 // struct LDKCVec_u8Z PaymentFailureReason_write(const enum LDKPaymentFailureReason *NONNULL_PTR obj);
56071 export function PaymentFailureReason_write(obj: bigint): number {
56072 if(!isWasmInitialized) {
56073 throw new Error("initializeWasm() must be awaited first!");
56075 const nativeResponseValue = wasm.TS_PaymentFailureReason_write(obj);
56076 return nativeResponseValue;
56078 // struct LDKCResult_PaymentFailureReasonDecodeErrorZ PaymentFailureReason_read(struct LDKu8slice ser);
56080 export function PaymentFailureReason_read(ser: number): bigint {
56081 if(!isWasmInitialized) {
56082 throw new Error("initializeWasm() must be awaited first!");
56084 const nativeResponseValue = wasm.TS_PaymentFailureReason_read(ser);
56085 return nativeResponseValue;
56087 // void Event_free(struct LDKEvent this_ptr);
56089 export function Event_free(this_ptr: bigint): void {
56090 if(!isWasmInitialized) {
56091 throw new Error("initializeWasm() must be awaited first!");
56093 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
56094 // debug statements here
56096 // uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
56098 export function Event_clone_ptr(arg: bigint): bigint {
56099 if(!isWasmInitialized) {
56100 throw new Error("initializeWasm() must be awaited first!");
56102 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
56103 return nativeResponseValue;
56105 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
56107 export function Event_clone(orig: bigint): bigint {
56108 if(!isWasmInitialized) {
56109 throw new Error("initializeWasm() must be awaited first!");
56111 const nativeResponseValue = wasm.TS_Event_clone(orig);
56112 return nativeResponseValue;
56114 // 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);
56116 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 {
56117 if(!isWasmInitialized) {
56118 throw new Error("initializeWasm() must be awaited first!");
56120 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
56121 return nativeResponseValue;
56123 // 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);
56125 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 {
56126 if(!isWasmInitialized) {
56127 throw new Error("initializeWasm() must be awaited first!");
56129 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);
56130 return nativeResponseValue;
56132 // 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);
56134 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 {
56135 if(!isWasmInitialized) {
56136 throw new Error("initializeWasm() must be awaited first!");
56138 const nativeResponseValue = wasm.TS_Event_payment_claimed(receiver_node_id, payment_hash, amount_msat, purpose, htlcs, sender_intended_total_msat);
56139 return nativeResponseValue;
56141 // struct LDKEvent Event_connection_needed(struct LDKPublicKey node_id, struct LDKCVec_SocketAddressZ addresses);
56143 export function Event_connection_needed(node_id: number, addresses: number): bigint {
56144 if(!isWasmInitialized) {
56145 throw new Error("initializeWasm() must be awaited first!");
56147 const nativeResponseValue = wasm.TS_Event_connection_needed(node_id, addresses);
56148 return nativeResponseValue;
56150 // struct LDKEvent Event_invoice_request_failed(struct LDKThirtyTwoBytes payment_id);
56152 export function Event_invoice_request_failed(payment_id: number): bigint {
56153 if(!isWasmInitialized) {
56154 throw new Error("initializeWasm() must be awaited first!");
56156 const nativeResponseValue = wasm.TS_Event_invoice_request_failed(payment_id);
56157 return nativeResponseValue;
56159 // struct LDKEvent Event_payment_sent(struct LDKCOption_ThirtyTwoBytesZ payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
56161 export function Event_payment_sent(payment_id: bigint, payment_preimage: number, payment_hash: number, fee_paid_msat: bigint): bigint {
56162 if(!isWasmInitialized) {
56163 throw new Error("initializeWasm() must be awaited first!");
56165 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
56166 return nativeResponseValue;
56168 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_PaymentFailureReasonZ reason);
56170 export function Event_payment_failed(payment_id: number, payment_hash: number, reason: bigint): bigint {
56171 if(!isWasmInitialized) {
56172 throw new Error("initializeWasm() must be awaited first!");
56174 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash, reason);
56175 return nativeResponseValue;
56177 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKCOption_ThirtyTwoBytesZ payment_hash, struct LDKPath path);
56179 export function Event_payment_path_successful(payment_id: number, payment_hash: bigint, path: bigint): bigint {
56180 if(!isWasmInitialized) {
56181 throw new Error("initializeWasm() must be awaited first!");
56183 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
56184 return nativeResponseValue;
56186 // 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);
56188 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 {
56189 if(!isWasmInitialized) {
56190 throw new Error("initializeWasm() must be awaited first!");
56192 const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, payment_failed_permanently, failure, path, short_channel_id);
56193 return nativeResponseValue;
56195 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path);
56197 export function Event_probe_successful(payment_id: number, payment_hash: number, path: bigint): bigint {
56198 if(!isWasmInitialized) {
56199 throw new Error("initializeWasm() must be awaited first!");
56201 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
56202 return nativeResponseValue;
56204 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKPath path, struct LDKCOption_u64Z short_channel_id);
56206 export function Event_probe_failed(payment_id: number, payment_hash: number, path: bigint, short_channel_id: bigint): bigint {
56207 if(!isWasmInitialized) {
56208 throw new Error("initializeWasm() must be awaited first!");
56210 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
56211 return nativeResponseValue;
56213 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
56215 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): bigint {
56216 if(!isWasmInitialized) {
56217 throw new Error("initializeWasm() must be awaited first!");
56219 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
56220 return nativeResponseValue;
56222 // 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);
56224 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 {
56225 if(!isWasmInitialized) {
56226 throw new Error("initializeWasm() must be awaited first!");
56228 const nativeResponseValue = wasm.TS_Event_htlcintercepted(intercept_id, requested_next_hop_scid, payment_hash, inbound_amount_msat, expected_outbound_amount_msat);
56229 return nativeResponseValue;
56231 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs, struct LDKCOption_ThirtyTwoBytesZ channel_id);
56233 export function Event_spendable_outputs(outputs: number, channel_id: bigint): bigint {
56234 if(!isWasmInitialized) {
56235 throw new Error("initializeWasm() must be awaited first!");
56237 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs, channel_id);
56238 return nativeResponseValue;
56240 // 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);
56242 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 {
56243 if(!isWasmInitialized) {
56244 throw new Error("initializeWasm() must be awaited first!");
56246 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx, outbound_amount_forwarded_msat);
56247 return nativeResponseValue;
56249 // 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);
56251 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 {
56252 if(!isWasmInitialized) {
56253 throw new Error("initializeWasm() must be awaited first!");
56255 const nativeResponseValue = wasm.TS_Event_channel_pending(channel_id, user_channel_id, former_temporary_channel_id, counterparty_node_id, funding_txo);
56256 return nativeResponseValue;
56258 // struct LDKEvent Event_channel_ready(struct LDKThirtyTwoBytes channel_id, struct LDKU128 user_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKChannelTypeFeatures channel_type);
56260 export function Event_channel_ready(channel_id: number, user_channel_id: number, counterparty_node_id: number, channel_type: bigint): bigint {
56261 if(!isWasmInitialized) {
56262 throw new Error("initializeWasm() must be awaited first!");
56264 const nativeResponseValue = wasm.TS_Event_channel_ready(channel_id, user_channel_id, counterparty_node_id, channel_type);
56265 return nativeResponseValue;
56267 // 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, struct LDKOutPoint channel_funding_txo);
56269 export function Event_channel_closed(channel_id: number, user_channel_id: number, reason: bigint, counterparty_node_id: number, channel_capacity_sats: bigint, channel_funding_txo: bigint): bigint {
56270 if(!isWasmInitialized) {
56271 throw new Error("initializeWasm() must be awaited first!");
56273 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason, counterparty_node_id, channel_capacity_sats, channel_funding_txo);
56274 return nativeResponseValue;
56276 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
56278 export function Event_discard_funding(channel_id: number, transaction: number): bigint {
56279 if(!isWasmInitialized) {
56280 throw new Error("initializeWasm() must be awaited first!");
56282 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
56283 return nativeResponseValue;
56285 // 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);
56287 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: bigint): bigint {
56288 if(!isWasmInitialized) {
56289 throw new Error("initializeWasm() must be awaited first!");
56291 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
56292 return nativeResponseValue;
56294 // struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
56296 export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: bigint): bigint {
56297 if(!isWasmInitialized) {
56298 throw new Error("initializeWasm() must be awaited first!");
56300 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
56301 return nativeResponseValue;
56303 // struct LDKEvent Event_bump_transaction(struct LDKBumpTransactionEvent a);
56305 export function Event_bump_transaction(a: bigint): bigint {
56306 if(!isWasmInitialized) {
56307 throw new Error("initializeWasm() must be awaited first!");
56309 const nativeResponseValue = wasm.TS_Event_bump_transaction(a);
56310 return nativeResponseValue;
56312 // bool Event_eq(const struct LDKEvent *NONNULL_PTR a, const struct LDKEvent *NONNULL_PTR b);
56314 export function Event_eq(a: bigint, b: bigint): boolean {
56315 if(!isWasmInitialized) {
56316 throw new Error("initializeWasm() must be awaited first!");
56318 const nativeResponseValue = wasm.TS_Event_eq(a, b);
56319 return nativeResponseValue;
56321 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
56323 export function Event_write(obj: bigint): number {
56324 if(!isWasmInitialized) {
56325 throw new Error("initializeWasm() must be awaited first!");
56327 const nativeResponseValue = wasm.TS_Event_write(obj);
56328 return nativeResponseValue;
56330 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
56332 export function Event_read(ser: number): bigint {
56333 if(!isWasmInitialized) {
56334 throw new Error("initializeWasm() must be awaited first!");
56336 const nativeResponseValue = wasm.TS_Event_read(ser);
56337 return nativeResponseValue;
56339 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
56341 export function MessageSendEvent_free(this_ptr: bigint): void {
56342 if(!isWasmInitialized) {
56343 throw new Error("initializeWasm() must be awaited first!");
56345 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
56346 // debug statements here
56348 // uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
56350 export function MessageSendEvent_clone_ptr(arg: bigint): bigint {
56351 if(!isWasmInitialized) {
56352 throw new Error("initializeWasm() must be awaited first!");
56354 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
56355 return nativeResponseValue;
56357 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
56359 export function MessageSendEvent_clone(orig: bigint): bigint {
56360 if(!isWasmInitialized) {
56361 throw new Error("initializeWasm() must be awaited first!");
56363 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
56364 return nativeResponseValue;
56366 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
56368 export function MessageSendEvent_send_accept_channel(node_id: number, msg: bigint): bigint {
56369 if(!isWasmInitialized) {
56370 throw new Error("initializeWasm() must be awaited first!");
56372 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
56373 return nativeResponseValue;
56375 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel_v2(struct LDKPublicKey node_id, struct LDKAcceptChannelV2 msg);
56377 export function MessageSendEvent_send_accept_channel_v2(node_id: number, msg: bigint): bigint {
56378 if(!isWasmInitialized) {
56379 throw new Error("initializeWasm() must be awaited first!");
56381 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel_v2(node_id, msg);
56382 return nativeResponseValue;
56384 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
56386 export function MessageSendEvent_send_open_channel(node_id: number, msg: bigint): bigint {
56387 if(!isWasmInitialized) {
56388 throw new Error("initializeWasm() must be awaited first!");
56390 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
56391 return nativeResponseValue;
56393 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel_v2(struct LDKPublicKey node_id, struct LDKOpenChannelV2 msg);
56395 export function MessageSendEvent_send_open_channel_v2(node_id: number, msg: bigint): bigint {
56396 if(!isWasmInitialized) {
56397 throw new Error("initializeWasm() must be awaited first!");
56399 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel_v2(node_id, msg);
56400 return nativeResponseValue;
56402 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
56404 export function MessageSendEvent_send_funding_created(node_id: number, msg: bigint): bigint {
56405 if(!isWasmInitialized) {
56406 throw new Error("initializeWasm() must be awaited first!");
56408 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
56409 return nativeResponseValue;
56411 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
56413 export function MessageSendEvent_send_funding_signed(node_id: number, msg: bigint): bigint {
56414 if(!isWasmInitialized) {
56415 throw new Error("initializeWasm() must be awaited first!");
56417 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
56418 return nativeResponseValue;
56420 // struct LDKMessageSendEvent MessageSendEvent_send_stfu(struct LDKPublicKey node_id, struct LDKStfu msg);
56422 export function MessageSendEvent_send_stfu(node_id: number, msg: bigint): bigint {
56423 if(!isWasmInitialized) {
56424 throw new Error("initializeWasm() must be awaited first!");
56426 const nativeResponseValue = wasm.TS_MessageSendEvent_send_stfu(node_id, msg);
56427 return nativeResponseValue;
56429 // struct LDKMessageSendEvent MessageSendEvent_send_splice(struct LDKPublicKey node_id, struct LDKSplice msg);
56431 export function MessageSendEvent_send_splice(node_id: number, msg: bigint): bigint {
56432 if(!isWasmInitialized) {
56433 throw new Error("initializeWasm() must be awaited first!");
56435 const nativeResponseValue = wasm.TS_MessageSendEvent_send_splice(node_id, msg);
56436 return nativeResponseValue;
56438 // struct LDKMessageSendEvent MessageSendEvent_send_splice_ack(struct LDKPublicKey node_id, struct LDKSpliceAck msg);
56440 export function MessageSendEvent_send_splice_ack(node_id: number, msg: bigint): bigint {
56441 if(!isWasmInitialized) {
56442 throw new Error("initializeWasm() must be awaited first!");
56444 const nativeResponseValue = wasm.TS_MessageSendEvent_send_splice_ack(node_id, msg);
56445 return nativeResponseValue;
56447 // struct LDKMessageSendEvent MessageSendEvent_send_splice_locked(struct LDKPublicKey node_id, struct LDKSpliceLocked msg);
56449 export function MessageSendEvent_send_splice_locked(node_id: number, msg: bigint): bigint {
56450 if(!isWasmInitialized) {
56451 throw new Error("initializeWasm() must be awaited first!");
56453 const nativeResponseValue = wasm.TS_MessageSendEvent_send_splice_locked(node_id, msg);
56454 return nativeResponseValue;
56456 // struct LDKMessageSendEvent MessageSendEvent_send_tx_add_input(struct LDKPublicKey node_id, struct LDKTxAddInput msg);
56458 export function MessageSendEvent_send_tx_add_input(node_id: number, msg: bigint): bigint {
56459 if(!isWasmInitialized) {
56460 throw new Error("initializeWasm() must be awaited first!");
56462 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_add_input(node_id, msg);
56463 return nativeResponseValue;
56465 // struct LDKMessageSendEvent MessageSendEvent_send_tx_add_output(struct LDKPublicKey node_id, struct LDKTxAddOutput msg);
56467 export function MessageSendEvent_send_tx_add_output(node_id: number, msg: bigint): bigint {
56468 if(!isWasmInitialized) {
56469 throw new Error("initializeWasm() must be awaited first!");
56471 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_add_output(node_id, msg);
56472 return nativeResponseValue;
56474 // struct LDKMessageSendEvent MessageSendEvent_send_tx_remove_input(struct LDKPublicKey node_id, struct LDKTxRemoveInput msg);
56476 export function MessageSendEvent_send_tx_remove_input(node_id: number, msg: bigint): bigint {
56477 if(!isWasmInitialized) {
56478 throw new Error("initializeWasm() must be awaited first!");
56480 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_remove_input(node_id, msg);
56481 return nativeResponseValue;
56483 // struct LDKMessageSendEvent MessageSendEvent_send_tx_remove_output(struct LDKPublicKey node_id, struct LDKTxRemoveOutput msg);
56485 export function MessageSendEvent_send_tx_remove_output(node_id: number, msg: bigint): bigint {
56486 if(!isWasmInitialized) {
56487 throw new Error("initializeWasm() must be awaited first!");
56489 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_remove_output(node_id, msg);
56490 return nativeResponseValue;
56492 // struct LDKMessageSendEvent MessageSendEvent_send_tx_complete(struct LDKPublicKey node_id, struct LDKTxComplete msg);
56494 export function MessageSendEvent_send_tx_complete(node_id: number, msg: bigint): bigint {
56495 if(!isWasmInitialized) {
56496 throw new Error("initializeWasm() must be awaited first!");
56498 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_complete(node_id, msg);
56499 return nativeResponseValue;
56501 // struct LDKMessageSendEvent MessageSendEvent_send_tx_signatures(struct LDKPublicKey node_id, struct LDKTxSignatures msg);
56503 export function MessageSendEvent_send_tx_signatures(node_id: number, msg: bigint): bigint {
56504 if(!isWasmInitialized) {
56505 throw new Error("initializeWasm() must be awaited first!");
56507 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_signatures(node_id, msg);
56508 return nativeResponseValue;
56510 // struct LDKMessageSendEvent MessageSendEvent_send_tx_init_rbf(struct LDKPublicKey node_id, struct LDKTxInitRbf msg);
56512 export function MessageSendEvent_send_tx_init_rbf(node_id: number, msg: bigint): bigint {
56513 if(!isWasmInitialized) {
56514 throw new Error("initializeWasm() must be awaited first!");
56516 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_init_rbf(node_id, msg);
56517 return nativeResponseValue;
56519 // struct LDKMessageSendEvent MessageSendEvent_send_tx_ack_rbf(struct LDKPublicKey node_id, struct LDKTxAckRbf msg);
56521 export function MessageSendEvent_send_tx_ack_rbf(node_id: number, msg: bigint): bigint {
56522 if(!isWasmInitialized) {
56523 throw new Error("initializeWasm() must be awaited first!");
56525 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_ack_rbf(node_id, msg);
56526 return nativeResponseValue;
56528 // struct LDKMessageSendEvent MessageSendEvent_send_tx_abort(struct LDKPublicKey node_id, struct LDKTxAbort msg);
56530 export function MessageSendEvent_send_tx_abort(node_id: number, msg: bigint): bigint {
56531 if(!isWasmInitialized) {
56532 throw new Error("initializeWasm() must be awaited first!");
56534 const nativeResponseValue = wasm.TS_MessageSendEvent_send_tx_abort(node_id, msg);
56535 return nativeResponseValue;
56537 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
56539 export function MessageSendEvent_send_channel_ready(node_id: number, msg: bigint): bigint {
56540 if(!isWasmInitialized) {
56541 throw new Error("initializeWasm() must be awaited first!");
56543 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
56544 return nativeResponseValue;
56546 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
56548 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: bigint): bigint {
56549 if(!isWasmInitialized) {
56550 throw new Error("initializeWasm() must be awaited first!");
56552 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
56553 return nativeResponseValue;
56555 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
56557 export function MessageSendEvent_update_htlcs(node_id: number, updates: bigint): bigint {
56558 if(!isWasmInitialized) {
56559 throw new Error("initializeWasm() must be awaited first!");
56561 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
56562 return nativeResponseValue;
56564 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
56566 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: bigint): bigint {
56567 if(!isWasmInitialized) {
56568 throw new Error("initializeWasm() must be awaited first!");
56570 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
56571 return nativeResponseValue;
56573 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
56575 export function MessageSendEvent_send_closing_signed(node_id: number, msg: bigint): bigint {
56576 if(!isWasmInitialized) {
56577 throw new Error("initializeWasm() must be awaited first!");
56579 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
56580 return nativeResponseValue;
56582 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
56584 export function MessageSendEvent_send_shutdown(node_id: number, msg: bigint): bigint {
56585 if(!isWasmInitialized) {
56586 throw new Error("initializeWasm() must be awaited first!");
56588 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
56589 return nativeResponseValue;
56591 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
56593 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: bigint): bigint {
56594 if(!isWasmInitialized) {
56595 throw new Error("initializeWasm() must be awaited first!");
56597 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
56598 return nativeResponseValue;
56600 // struct LDKMessageSendEvent MessageSendEvent_send_channel_announcement(struct LDKPublicKey node_id, struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
56602 export function MessageSendEvent_send_channel_announcement(node_id: number, msg: bigint, update_msg: bigint): bigint {
56603 if(!isWasmInitialized) {
56604 throw new Error("initializeWasm() must be awaited first!");
56606 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_announcement(node_id, msg, update_msg);
56607 return nativeResponseValue;
56609 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
56611 export function MessageSendEvent_broadcast_channel_announcement(msg: bigint, update_msg: bigint): bigint {
56612 if(!isWasmInitialized) {
56613 throw new Error("initializeWasm() must be awaited first!");
56615 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
56616 return nativeResponseValue;
56618 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
56620 export function MessageSendEvent_broadcast_channel_update(msg: bigint): bigint {
56621 if(!isWasmInitialized) {
56622 throw new Error("initializeWasm() must be awaited first!");
56624 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
56625 return nativeResponseValue;
56627 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
56629 export function MessageSendEvent_broadcast_node_announcement(msg: bigint): bigint {
56630 if(!isWasmInitialized) {
56631 throw new Error("initializeWasm() must be awaited first!");
56633 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
56634 return nativeResponseValue;
56636 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
56638 export function MessageSendEvent_send_channel_update(node_id: number, msg: bigint): bigint {
56639 if(!isWasmInitialized) {
56640 throw new Error("initializeWasm() must be awaited first!");
56642 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
56643 return nativeResponseValue;
56645 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
56647 export function MessageSendEvent_handle_error(node_id: number, action: bigint): bigint {
56648 if(!isWasmInitialized) {
56649 throw new Error("initializeWasm() must be awaited first!");
56651 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
56652 return nativeResponseValue;
56654 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
56656 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: bigint): bigint {
56657 if(!isWasmInitialized) {
56658 throw new Error("initializeWasm() must be awaited first!");
56660 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
56661 return nativeResponseValue;
56663 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
56665 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: bigint): bigint {
56666 if(!isWasmInitialized) {
56667 throw new Error("initializeWasm() must be awaited first!");
56669 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
56670 return nativeResponseValue;
56672 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
56674 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: bigint): bigint {
56675 if(!isWasmInitialized) {
56676 throw new Error("initializeWasm() must be awaited first!");
56678 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
56679 return nativeResponseValue;
56681 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
56683 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: bigint): bigint {
56684 if(!isWasmInitialized) {
56685 throw new Error("initializeWasm() must be awaited first!");
56687 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
56688 return nativeResponseValue;
56690 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
56692 export function MessageSendEventsProvider_free(this_ptr: bigint): void {
56693 if(!isWasmInitialized) {
56694 throw new Error("initializeWasm() must be awaited first!");
56696 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
56697 // debug statements here
56699 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
56701 export function EventsProvider_free(this_ptr: bigint): void {
56702 if(!isWasmInitialized) {
56703 throw new Error("initializeWasm() must be awaited first!");
56705 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
56706 // debug statements here
56708 // void EventHandler_free(struct LDKEventHandler this_ptr);
56710 export function EventHandler_free(this_ptr: bigint): void {
56711 if(!isWasmInitialized) {
56712 throw new Error("initializeWasm() must be awaited first!");
56714 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
56715 // debug statements here
56717 // void AnchorDescriptor_free(struct LDKAnchorDescriptor this_obj);
56719 export function AnchorDescriptor_free(this_obj: bigint): void {
56720 if(!isWasmInitialized) {
56721 throw new Error("initializeWasm() must be awaited first!");
56723 const nativeResponseValue = wasm.TS_AnchorDescriptor_free(this_obj);
56724 // debug statements here
56726 // struct LDKChannelDerivationParameters AnchorDescriptor_get_channel_derivation_parameters(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
56728 export function AnchorDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
56729 if(!isWasmInitialized) {
56730 throw new Error("initializeWasm() must be awaited first!");
56732 const nativeResponseValue = wasm.TS_AnchorDescriptor_get_channel_derivation_parameters(this_ptr);
56733 return nativeResponseValue;
56735 // void AnchorDescriptor_set_channel_derivation_parameters(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
56737 export function AnchorDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
56738 if(!isWasmInitialized) {
56739 throw new Error("initializeWasm() must be awaited first!");
56741 const nativeResponseValue = wasm.TS_AnchorDescriptor_set_channel_derivation_parameters(this_ptr, val);
56742 // debug statements here
56744 // struct LDKOutPoint AnchorDescriptor_get_outpoint(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
56746 export function AnchorDescriptor_get_outpoint(this_ptr: bigint): bigint {
56747 if(!isWasmInitialized) {
56748 throw new Error("initializeWasm() must be awaited first!");
56750 const nativeResponseValue = wasm.TS_AnchorDescriptor_get_outpoint(this_ptr);
56751 return nativeResponseValue;
56753 // void AnchorDescriptor_set_outpoint(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
56755 export function AnchorDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
56756 if(!isWasmInitialized) {
56757 throw new Error("initializeWasm() must be awaited first!");
56759 const nativeResponseValue = wasm.TS_AnchorDescriptor_set_outpoint(this_ptr, val);
56760 // debug statements here
56762 // MUST_USE_RES struct LDKAnchorDescriptor AnchorDescriptor_new(struct LDKChannelDerivationParameters channel_derivation_parameters_arg, struct LDKOutPoint outpoint_arg);
56764 export function AnchorDescriptor_new(channel_derivation_parameters_arg: bigint, outpoint_arg: bigint): bigint {
56765 if(!isWasmInitialized) {
56766 throw new Error("initializeWasm() must be awaited first!");
56768 const nativeResponseValue = wasm.TS_AnchorDescriptor_new(channel_derivation_parameters_arg, outpoint_arg);
56769 return nativeResponseValue;
56771 // uint64_t AnchorDescriptor_clone_ptr(LDKAnchorDescriptor *NONNULL_PTR arg);
56773 export function AnchorDescriptor_clone_ptr(arg: bigint): bigint {
56774 if(!isWasmInitialized) {
56775 throw new Error("initializeWasm() must be awaited first!");
56777 const nativeResponseValue = wasm.TS_AnchorDescriptor_clone_ptr(arg);
56778 return nativeResponseValue;
56780 // struct LDKAnchorDescriptor AnchorDescriptor_clone(const struct LDKAnchorDescriptor *NONNULL_PTR orig);
56782 export function AnchorDescriptor_clone(orig: bigint): bigint {
56783 if(!isWasmInitialized) {
56784 throw new Error("initializeWasm() must be awaited first!");
56786 const nativeResponseValue = wasm.TS_AnchorDescriptor_clone(orig);
56787 return nativeResponseValue;
56789 // bool AnchorDescriptor_eq(const struct LDKAnchorDescriptor *NONNULL_PTR a, const struct LDKAnchorDescriptor *NONNULL_PTR b);
56791 export function AnchorDescriptor_eq(a: bigint, b: bigint): boolean {
56792 if(!isWasmInitialized) {
56793 throw new Error("initializeWasm() must be awaited first!");
56795 const nativeResponseValue = wasm.TS_AnchorDescriptor_eq(a, b);
56796 return nativeResponseValue;
56798 // MUST_USE_RES struct LDKTxOut AnchorDescriptor_previous_utxo(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
56800 export function AnchorDescriptor_previous_utxo(this_arg: bigint): bigint {
56801 if(!isWasmInitialized) {
56802 throw new Error("initializeWasm() must be awaited first!");
56804 const nativeResponseValue = wasm.TS_AnchorDescriptor_previous_utxo(this_arg);
56805 return nativeResponseValue;
56807 // MUST_USE_RES struct LDKTxIn AnchorDescriptor_unsigned_tx_input(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
56809 export function AnchorDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
56810 if(!isWasmInitialized) {
56811 throw new Error("initializeWasm() must be awaited first!");
56813 const nativeResponseValue = wasm.TS_AnchorDescriptor_unsigned_tx_input(this_arg);
56814 return nativeResponseValue;
56816 // MUST_USE_RES struct LDKCVec_u8Z AnchorDescriptor_witness_script(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
56818 export function AnchorDescriptor_witness_script(this_arg: bigint): number {
56819 if(!isWasmInitialized) {
56820 throw new Error("initializeWasm() must be awaited first!");
56822 const nativeResponseValue = wasm.TS_AnchorDescriptor_witness_script(this_arg);
56823 return nativeResponseValue;
56825 // MUST_USE_RES struct LDKWitness AnchorDescriptor_tx_input_witness(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, struct LDKECDSASignature signature);
56827 export function AnchorDescriptor_tx_input_witness(this_arg: bigint, signature: number): number {
56828 if(!isWasmInitialized) {
56829 throw new Error("initializeWasm() must be awaited first!");
56831 const nativeResponseValue = wasm.TS_AnchorDescriptor_tx_input_witness(this_arg, signature);
56832 return nativeResponseValue;
56834 // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner AnchorDescriptor_derive_channel_signer(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
56836 export function AnchorDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
56837 if(!isWasmInitialized) {
56838 throw new Error("initializeWasm() must be awaited first!");
56840 const nativeResponseValue = wasm.TS_AnchorDescriptor_derive_channel_signer(this_arg, signer_provider);
56841 return nativeResponseValue;
56843 // void BumpTransactionEvent_free(struct LDKBumpTransactionEvent this_ptr);
56845 export function BumpTransactionEvent_free(this_ptr: bigint): void {
56846 if(!isWasmInitialized) {
56847 throw new Error("initializeWasm() must be awaited first!");
56849 const nativeResponseValue = wasm.TS_BumpTransactionEvent_free(this_ptr);
56850 // debug statements here
56852 // uint64_t BumpTransactionEvent_clone_ptr(LDKBumpTransactionEvent *NONNULL_PTR arg);
56854 export function BumpTransactionEvent_clone_ptr(arg: bigint): bigint {
56855 if(!isWasmInitialized) {
56856 throw new Error("initializeWasm() must be awaited first!");
56858 const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone_ptr(arg);
56859 return nativeResponseValue;
56861 // struct LDKBumpTransactionEvent BumpTransactionEvent_clone(const struct LDKBumpTransactionEvent *NONNULL_PTR orig);
56863 export function BumpTransactionEvent_clone(orig: bigint): bigint {
56864 if(!isWasmInitialized) {
56865 throw new Error("initializeWasm() must be awaited first!");
56867 const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone(orig);
56868 return nativeResponseValue;
56870 // 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);
56872 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 {
56873 if(!isWasmInitialized) {
56874 throw new Error("initializeWasm() must be awaited first!");
56876 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);
56877 return nativeResponseValue;
56879 // 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);
56881 export function BumpTransactionEvent_htlcresolution(claim_id: number, target_feerate_sat_per_1000_weight: number, htlc_descriptors: number, tx_lock_time: number): bigint {
56882 if(!isWasmInitialized) {
56883 throw new Error("initializeWasm() must be awaited first!");
56885 const nativeResponseValue = wasm.TS_BumpTransactionEvent_htlcresolution(claim_id, target_feerate_sat_per_1000_weight, htlc_descriptors, tx_lock_time);
56886 return nativeResponseValue;
56888 // bool BumpTransactionEvent_eq(const struct LDKBumpTransactionEvent *NONNULL_PTR a, const struct LDKBumpTransactionEvent *NONNULL_PTR b);
56890 export function BumpTransactionEvent_eq(a: bigint, b: bigint): boolean {
56891 if(!isWasmInitialized) {
56892 throw new Error("initializeWasm() must be awaited first!");
56894 const nativeResponseValue = wasm.TS_BumpTransactionEvent_eq(a, b);
56895 return nativeResponseValue;
56897 // void Input_free(struct LDKInput this_obj);
56899 export function Input_free(this_obj: bigint): void {
56900 if(!isWasmInitialized) {
56901 throw new Error("initializeWasm() must be awaited first!");
56903 const nativeResponseValue = wasm.TS_Input_free(this_obj);
56904 // debug statements here
56906 // struct LDKOutPoint Input_get_outpoint(const struct LDKInput *NONNULL_PTR this_ptr);
56908 export function Input_get_outpoint(this_ptr: bigint): bigint {
56909 if(!isWasmInitialized) {
56910 throw new Error("initializeWasm() must be awaited first!");
56912 const nativeResponseValue = wasm.TS_Input_get_outpoint(this_ptr);
56913 return nativeResponseValue;
56915 // void Input_set_outpoint(struct LDKInput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
56917 export function Input_set_outpoint(this_ptr: bigint, val: bigint): void {
56918 if(!isWasmInitialized) {
56919 throw new Error("initializeWasm() must be awaited first!");
56921 const nativeResponseValue = wasm.TS_Input_set_outpoint(this_ptr, val);
56922 // debug statements here
56924 // struct LDKTxOut Input_get_previous_utxo(const struct LDKInput *NONNULL_PTR this_ptr);
56926 export function Input_get_previous_utxo(this_ptr: bigint): bigint {
56927 if(!isWasmInitialized) {
56928 throw new Error("initializeWasm() must be awaited first!");
56930 const nativeResponseValue = wasm.TS_Input_get_previous_utxo(this_ptr);
56931 return nativeResponseValue;
56933 // void Input_set_previous_utxo(struct LDKInput *NONNULL_PTR this_ptr, struct LDKTxOut val);
56935 export function Input_set_previous_utxo(this_ptr: bigint, val: bigint): void {
56936 if(!isWasmInitialized) {
56937 throw new Error("initializeWasm() must be awaited first!");
56939 const nativeResponseValue = wasm.TS_Input_set_previous_utxo(this_ptr, val);
56940 // debug statements here
56942 // uint64_t Input_get_satisfaction_weight(const struct LDKInput *NONNULL_PTR this_ptr);
56944 export function Input_get_satisfaction_weight(this_ptr: bigint): bigint {
56945 if(!isWasmInitialized) {
56946 throw new Error("initializeWasm() must be awaited first!");
56948 const nativeResponseValue = wasm.TS_Input_get_satisfaction_weight(this_ptr);
56949 return nativeResponseValue;
56951 // void Input_set_satisfaction_weight(struct LDKInput *NONNULL_PTR this_ptr, uint64_t val);
56953 export function Input_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
56954 if(!isWasmInitialized) {
56955 throw new Error("initializeWasm() must be awaited first!");
56957 const nativeResponseValue = wasm.TS_Input_set_satisfaction_weight(this_ptr, val);
56958 // debug statements here
56960 // MUST_USE_RES struct LDKInput Input_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut previous_utxo_arg, uint64_t satisfaction_weight_arg);
56962 export function Input_new(outpoint_arg: bigint, previous_utxo_arg: bigint, satisfaction_weight_arg: bigint): bigint {
56963 if(!isWasmInitialized) {
56964 throw new Error("initializeWasm() must be awaited first!");
56966 const nativeResponseValue = wasm.TS_Input_new(outpoint_arg, previous_utxo_arg, satisfaction_weight_arg);
56967 return nativeResponseValue;
56969 // uint64_t Input_clone_ptr(LDKInput *NONNULL_PTR arg);
56971 export function Input_clone_ptr(arg: bigint): bigint {
56972 if(!isWasmInitialized) {
56973 throw new Error("initializeWasm() must be awaited first!");
56975 const nativeResponseValue = wasm.TS_Input_clone_ptr(arg);
56976 return nativeResponseValue;
56978 // struct LDKInput Input_clone(const struct LDKInput *NONNULL_PTR orig);
56980 export function Input_clone(orig: bigint): bigint {
56981 if(!isWasmInitialized) {
56982 throw new Error("initializeWasm() must be awaited first!");
56984 const nativeResponseValue = wasm.TS_Input_clone(orig);
56985 return nativeResponseValue;
56987 // uint64_t Input_hash(const struct LDKInput *NONNULL_PTR o);
56989 export function Input_hash(o: bigint): bigint {
56990 if(!isWasmInitialized) {
56991 throw new Error("initializeWasm() must be awaited first!");
56993 const nativeResponseValue = wasm.TS_Input_hash(o);
56994 return nativeResponseValue;
56996 // bool Input_eq(const struct LDKInput *NONNULL_PTR a, const struct LDKInput *NONNULL_PTR b);
56998 export function Input_eq(a: bigint, b: bigint): boolean {
56999 if(!isWasmInitialized) {
57000 throw new Error("initializeWasm() must be awaited first!");
57002 const nativeResponseValue = wasm.TS_Input_eq(a, b);
57003 return nativeResponseValue;
57005 // void Utxo_free(struct LDKUtxo this_obj);
57007 export function Utxo_free(this_obj: bigint): void {
57008 if(!isWasmInitialized) {
57009 throw new Error("initializeWasm() must be awaited first!");
57011 const nativeResponseValue = wasm.TS_Utxo_free(this_obj);
57012 // debug statements here
57014 // struct LDKOutPoint Utxo_get_outpoint(const struct LDKUtxo *NONNULL_PTR this_ptr);
57016 export function Utxo_get_outpoint(this_ptr: bigint): bigint {
57017 if(!isWasmInitialized) {
57018 throw new Error("initializeWasm() must be awaited first!");
57020 const nativeResponseValue = wasm.TS_Utxo_get_outpoint(this_ptr);
57021 return nativeResponseValue;
57023 // void Utxo_set_outpoint(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKOutPoint val);
57025 export function Utxo_set_outpoint(this_ptr: bigint, val: bigint): void {
57026 if(!isWasmInitialized) {
57027 throw new Error("initializeWasm() must be awaited first!");
57029 const nativeResponseValue = wasm.TS_Utxo_set_outpoint(this_ptr, val);
57030 // debug statements here
57032 // struct LDKTxOut Utxo_get_output(const struct LDKUtxo *NONNULL_PTR this_ptr);
57034 export function Utxo_get_output(this_ptr: bigint): bigint {
57035 if(!isWasmInitialized) {
57036 throw new Error("initializeWasm() must be awaited first!");
57038 const nativeResponseValue = wasm.TS_Utxo_get_output(this_ptr);
57039 return nativeResponseValue;
57041 // void Utxo_set_output(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKTxOut val);
57043 export function Utxo_set_output(this_ptr: bigint, val: bigint): void {
57044 if(!isWasmInitialized) {
57045 throw new Error("initializeWasm() must be awaited first!");
57047 const nativeResponseValue = wasm.TS_Utxo_set_output(this_ptr, val);
57048 // debug statements here
57050 // uint64_t Utxo_get_satisfaction_weight(const struct LDKUtxo *NONNULL_PTR this_ptr);
57052 export function Utxo_get_satisfaction_weight(this_ptr: bigint): bigint {
57053 if(!isWasmInitialized) {
57054 throw new Error("initializeWasm() must be awaited first!");
57056 const nativeResponseValue = wasm.TS_Utxo_get_satisfaction_weight(this_ptr);
57057 return nativeResponseValue;
57059 // void Utxo_set_satisfaction_weight(struct LDKUtxo *NONNULL_PTR this_ptr, uint64_t val);
57061 export function Utxo_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
57062 if(!isWasmInitialized) {
57063 throw new Error("initializeWasm() must be awaited first!");
57065 const nativeResponseValue = wasm.TS_Utxo_set_satisfaction_weight(this_ptr, val);
57066 // debug statements here
57068 // MUST_USE_RES struct LDKUtxo Utxo_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut output_arg, uint64_t satisfaction_weight_arg);
57070 export function Utxo_new(outpoint_arg: bigint, output_arg: bigint, satisfaction_weight_arg: bigint): bigint {
57071 if(!isWasmInitialized) {
57072 throw new Error("initializeWasm() must be awaited first!");
57074 const nativeResponseValue = wasm.TS_Utxo_new(outpoint_arg, output_arg, satisfaction_weight_arg);
57075 return nativeResponseValue;
57077 // uint64_t Utxo_clone_ptr(LDKUtxo *NONNULL_PTR arg);
57079 export function Utxo_clone_ptr(arg: bigint): bigint {
57080 if(!isWasmInitialized) {
57081 throw new Error("initializeWasm() must be awaited first!");
57083 const nativeResponseValue = wasm.TS_Utxo_clone_ptr(arg);
57084 return nativeResponseValue;
57086 // struct LDKUtxo Utxo_clone(const struct LDKUtxo *NONNULL_PTR orig);
57088 export function Utxo_clone(orig: bigint): bigint {
57089 if(!isWasmInitialized) {
57090 throw new Error("initializeWasm() must be awaited first!");
57092 const nativeResponseValue = wasm.TS_Utxo_clone(orig);
57093 return nativeResponseValue;
57095 // uint64_t Utxo_hash(const struct LDKUtxo *NONNULL_PTR o);
57097 export function Utxo_hash(o: bigint): bigint {
57098 if(!isWasmInitialized) {
57099 throw new Error("initializeWasm() must be awaited first!");
57101 const nativeResponseValue = wasm.TS_Utxo_hash(o);
57102 return nativeResponseValue;
57104 // bool Utxo_eq(const struct LDKUtxo *NONNULL_PTR a, const struct LDKUtxo *NONNULL_PTR b);
57106 export function Utxo_eq(a: bigint, b: bigint): boolean {
57107 if(!isWasmInitialized) {
57108 throw new Error("initializeWasm() must be awaited first!");
57110 const nativeResponseValue = wasm.TS_Utxo_eq(a, b);
57111 return nativeResponseValue;
57113 // MUST_USE_RES struct LDKUtxo Utxo_new_p2pkh(struct LDKOutPoint outpoint, uint64_t value, const uint8_t (*pubkey_hash)[20]);
57115 export function Utxo_new_p2pkh(outpoint: bigint, value: bigint, pubkey_hash: number): bigint {
57116 if(!isWasmInitialized) {
57117 throw new Error("initializeWasm() must be awaited first!");
57119 const nativeResponseValue = wasm.TS_Utxo_new_p2pkh(outpoint, value, pubkey_hash);
57120 return nativeResponseValue;
57122 // void CoinSelection_free(struct LDKCoinSelection this_obj);
57124 export function CoinSelection_free(this_obj: bigint): void {
57125 if(!isWasmInitialized) {
57126 throw new Error("initializeWasm() must be awaited first!");
57128 const nativeResponseValue = wasm.TS_CoinSelection_free(this_obj);
57129 // debug statements here
57131 // struct LDKCVec_UtxoZ CoinSelection_get_confirmed_utxos(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
57133 export function CoinSelection_get_confirmed_utxos(this_ptr: bigint): number {
57134 if(!isWasmInitialized) {
57135 throw new Error("initializeWasm() must be awaited first!");
57137 const nativeResponseValue = wasm.TS_CoinSelection_get_confirmed_utxos(this_ptr);
57138 return nativeResponseValue;
57140 // void CoinSelection_set_confirmed_utxos(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCVec_UtxoZ val);
57142 export function CoinSelection_set_confirmed_utxos(this_ptr: bigint, val: number): void {
57143 if(!isWasmInitialized) {
57144 throw new Error("initializeWasm() must be awaited first!");
57146 const nativeResponseValue = wasm.TS_CoinSelection_set_confirmed_utxos(this_ptr, val);
57147 // debug statements here
57149 // struct LDKCOption_TxOutZ CoinSelection_get_change_output(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
57151 export function CoinSelection_get_change_output(this_ptr: bigint): bigint {
57152 if(!isWasmInitialized) {
57153 throw new Error("initializeWasm() must be awaited first!");
57155 const nativeResponseValue = wasm.TS_CoinSelection_get_change_output(this_ptr);
57156 return nativeResponseValue;
57158 // void CoinSelection_set_change_output(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCOption_TxOutZ val);
57160 export function CoinSelection_set_change_output(this_ptr: bigint, val: bigint): void {
57161 if(!isWasmInitialized) {
57162 throw new Error("initializeWasm() must be awaited first!");
57164 const nativeResponseValue = wasm.TS_CoinSelection_set_change_output(this_ptr, val);
57165 // debug statements here
57167 // MUST_USE_RES struct LDKCoinSelection CoinSelection_new(struct LDKCVec_UtxoZ confirmed_utxos_arg, struct LDKCOption_TxOutZ change_output_arg);
57169 export function CoinSelection_new(confirmed_utxos_arg: number, change_output_arg: bigint): bigint {
57170 if(!isWasmInitialized) {
57171 throw new Error("initializeWasm() must be awaited first!");
57173 const nativeResponseValue = wasm.TS_CoinSelection_new(confirmed_utxos_arg, change_output_arg);
57174 return nativeResponseValue;
57176 // uint64_t CoinSelection_clone_ptr(LDKCoinSelection *NONNULL_PTR arg);
57178 export function CoinSelection_clone_ptr(arg: bigint): bigint {
57179 if(!isWasmInitialized) {
57180 throw new Error("initializeWasm() must be awaited first!");
57182 const nativeResponseValue = wasm.TS_CoinSelection_clone_ptr(arg);
57183 return nativeResponseValue;
57185 // struct LDKCoinSelection CoinSelection_clone(const struct LDKCoinSelection *NONNULL_PTR orig);
57187 export function CoinSelection_clone(orig: bigint): bigint {
57188 if(!isWasmInitialized) {
57189 throw new Error("initializeWasm() must be awaited first!");
57191 const nativeResponseValue = wasm.TS_CoinSelection_clone(orig);
57192 return nativeResponseValue;
57194 // void CoinSelectionSource_free(struct LDKCoinSelectionSource this_ptr);
57196 export function CoinSelectionSource_free(this_ptr: bigint): void {
57197 if(!isWasmInitialized) {
57198 throw new Error("initializeWasm() must be awaited first!");
57200 const nativeResponseValue = wasm.TS_CoinSelectionSource_free(this_ptr);
57201 // debug statements here
57203 // void WalletSource_free(struct LDKWalletSource this_ptr);
57205 export function WalletSource_free(this_ptr: bigint): void {
57206 if(!isWasmInitialized) {
57207 throw new Error("initializeWasm() must be awaited first!");
57209 const nativeResponseValue = wasm.TS_WalletSource_free(this_ptr);
57210 // debug statements here
57212 // void Wallet_free(struct LDKWallet this_obj);
57214 export function Wallet_free(this_obj: bigint): void {
57215 if(!isWasmInitialized) {
57216 throw new Error("initializeWasm() must be awaited first!");
57218 const nativeResponseValue = wasm.TS_Wallet_free(this_obj);
57219 // debug statements here
57221 // MUST_USE_RES struct LDKWallet Wallet_new(struct LDKWalletSource source, struct LDKLogger logger);
57223 export function Wallet_new(source: bigint, logger: bigint): bigint {
57224 if(!isWasmInitialized) {
57225 throw new Error("initializeWasm() must be awaited first!");
57227 const nativeResponseValue = wasm.TS_Wallet_new(source, logger);
57228 return nativeResponseValue;
57230 // struct LDKCoinSelectionSource Wallet_as_CoinSelectionSource(const struct LDKWallet *NONNULL_PTR this_arg);
57232 export function Wallet_as_CoinSelectionSource(this_arg: bigint): bigint {
57233 if(!isWasmInitialized) {
57234 throw new Error("initializeWasm() must be awaited first!");
57236 const nativeResponseValue = wasm.TS_Wallet_as_CoinSelectionSource(this_arg);
57237 return nativeResponseValue;
57239 // void BumpTransactionEventHandler_free(struct LDKBumpTransactionEventHandler this_obj);
57241 export function BumpTransactionEventHandler_free(this_obj: bigint): void {
57242 if(!isWasmInitialized) {
57243 throw new Error("initializeWasm() must be awaited first!");
57245 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_free(this_obj);
57246 // debug statements here
57248 // MUST_USE_RES struct LDKBumpTransactionEventHandler BumpTransactionEventHandler_new(struct LDKBroadcasterInterface broadcaster, struct LDKCoinSelectionSource utxo_source, struct LDKSignerProvider signer_provider, struct LDKLogger logger);
57250 export function BumpTransactionEventHandler_new(broadcaster: bigint, utxo_source: bigint, signer_provider: bigint, logger: bigint): bigint {
57251 if(!isWasmInitialized) {
57252 throw new Error("initializeWasm() must be awaited first!");
57254 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_new(broadcaster, utxo_source, signer_provider, logger);
57255 return nativeResponseValue;
57257 // void BumpTransactionEventHandler_handle_event(const struct LDKBumpTransactionEventHandler *NONNULL_PTR this_arg, const struct LDKBumpTransactionEvent *NONNULL_PTR event);
57259 export function BumpTransactionEventHandler_handle_event(this_arg: bigint, event: bigint): void {
57260 if(!isWasmInitialized) {
57261 throw new Error("initializeWasm() must be awaited first!");
57263 const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_handle_event(this_arg, event);
57264 // debug statements here
57266 // void GossipSync_free(struct LDKGossipSync this_ptr);
57268 export function GossipSync_free(this_ptr: bigint): void {
57269 if(!isWasmInitialized) {
57270 throw new Error("initializeWasm() must be awaited first!");
57272 const nativeResponseValue = wasm.TS_GossipSync_free(this_ptr);
57273 // debug statements here
57275 // struct LDKGossipSync GossipSync_p2_p(const struct LDKP2PGossipSync *NONNULL_PTR a);
57277 export function GossipSync_p2_p(a: bigint): bigint {
57278 if(!isWasmInitialized) {
57279 throw new Error("initializeWasm() must be awaited first!");
57281 const nativeResponseValue = wasm.TS_GossipSync_p2_p(a);
57282 return nativeResponseValue;
57284 // struct LDKGossipSync GossipSync_rapid(const struct LDKRapidGossipSync *NONNULL_PTR a);
57286 export function GossipSync_rapid(a: bigint): bigint {
57287 if(!isWasmInitialized) {
57288 throw new Error("initializeWasm() must be awaited first!");
57290 const nativeResponseValue = wasm.TS_GossipSync_rapid(a);
57291 return nativeResponseValue;
57293 // struct LDKGossipSync GossipSync_none(void);
57295 export function GossipSync_none(): bigint {
57296 if(!isWasmInitialized) {
57297 throw new Error("initializeWasm() must be awaited first!");
57299 const nativeResponseValue = wasm.TS_GossipSync_none();
57300 return nativeResponseValue;
57302 // void GraphSyncError_free(struct LDKGraphSyncError this_ptr);
57304 export function GraphSyncError_free(this_ptr: bigint): void {
57305 if(!isWasmInitialized) {
57306 throw new Error("initializeWasm() must be awaited first!");
57308 const nativeResponseValue = wasm.TS_GraphSyncError_free(this_ptr);
57309 // debug statements here
57311 // uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg);
57313 export function GraphSyncError_clone_ptr(arg: bigint): bigint {
57314 if(!isWasmInitialized) {
57315 throw new Error("initializeWasm() must be awaited first!");
57317 const nativeResponseValue = wasm.TS_GraphSyncError_clone_ptr(arg);
57318 return nativeResponseValue;
57320 // struct LDKGraphSyncError GraphSyncError_clone(const struct LDKGraphSyncError *NONNULL_PTR orig);
57322 export function GraphSyncError_clone(orig: bigint): bigint {
57323 if(!isWasmInitialized) {
57324 throw new Error("initializeWasm() must be awaited first!");
57326 const nativeResponseValue = wasm.TS_GraphSyncError_clone(orig);
57327 return nativeResponseValue;
57329 // struct LDKGraphSyncError GraphSyncError_decode_error(struct LDKDecodeError a);
57331 export function GraphSyncError_decode_error(a: bigint): bigint {
57332 if(!isWasmInitialized) {
57333 throw new Error("initializeWasm() must be awaited first!");
57335 const nativeResponseValue = wasm.TS_GraphSyncError_decode_error(a);
57336 return nativeResponseValue;
57338 // struct LDKGraphSyncError GraphSyncError_lightning_error(struct LDKLightningError a);
57340 export function GraphSyncError_lightning_error(a: bigint): bigint {
57341 if(!isWasmInitialized) {
57342 throw new Error("initializeWasm() must be awaited first!");
57344 const nativeResponseValue = wasm.TS_GraphSyncError_lightning_error(a);
57345 return nativeResponseValue;
57347 // void RapidGossipSync_free(struct LDKRapidGossipSync this_obj);
57349 export function RapidGossipSync_free(this_obj: bigint): void {
57350 if(!isWasmInitialized) {
57351 throw new Error("initializeWasm() must be awaited first!");
57353 const nativeResponseValue = wasm.TS_RapidGossipSync_free(this_obj);
57354 // debug statements here
57356 // MUST_USE_RES struct LDKRapidGossipSync RapidGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
57358 export function RapidGossipSync_new(network_graph: bigint, logger: bigint): bigint {
57359 if(!isWasmInitialized) {
57360 throw new Error("initializeWasm() must be awaited first!");
57362 const nativeResponseValue = wasm.TS_RapidGossipSync_new(network_graph, logger);
57363 return nativeResponseValue;
57365 // 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);
57367 export function RapidGossipSync_update_network_graph_no_std(this_arg: bigint, update_data: number, current_time_unix: bigint): bigint {
57368 if(!isWasmInitialized) {
57369 throw new Error("initializeWasm() must be awaited first!");
57371 const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph_no_std(this_arg, update_data, current_time_unix);
57372 return nativeResponseValue;
57374 // MUST_USE_RES bool RapidGossipSync_is_initial_sync_complete(const struct LDKRapidGossipSync *NONNULL_PTR this_arg);
57376 export function RapidGossipSync_is_initial_sync_complete(this_arg: bigint): boolean {
57377 if(!isWasmInitialized) {
57378 throw new Error("initializeWasm() must be awaited first!");
57380 const nativeResponseValue = wasm.TS_RapidGossipSync_is_initial_sync_complete(this_arg);
57381 return nativeResponseValue;
57383 // void Bolt11ParseError_free(struct LDKBolt11ParseError this_ptr);
57385 export function Bolt11ParseError_free(this_ptr: bigint): void {
57386 if(!isWasmInitialized) {
57387 throw new Error("initializeWasm() must be awaited first!");
57389 const nativeResponseValue = wasm.TS_Bolt11ParseError_free(this_ptr);
57390 // debug statements here
57392 // uint64_t Bolt11ParseError_clone_ptr(LDKBolt11ParseError *NONNULL_PTR arg);
57394 export function Bolt11ParseError_clone_ptr(arg: bigint): bigint {
57395 if(!isWasmInitialized) {
57396 throw new Error("initializeWasm() must be awaited first!");
57398 const nativeResponseValue = wasm.TS_Bolt11ParseError_clone_ptr(arg);
57399 return nativeResponseValue;
57401 // struct LDKBolt11ParseError Bolt11ParseError_clone(const struct LDKBolt11ParseError *NONNULL_PTR orig);
57403 export function Bolt11ParseError_clone(orig: bigint): bigint {
57404 if(!isWasmInitialized) {
57405 throw new Error("initializeWasm() must be awaited first!");
57407 const nativeResponseValue = wasm.TS_Bolt11ParseError_clone(orig);
57408 return nativeResponseValue;
57410 // struct LDKBolt11ParseError Bolt11ParseError_bech32_error(struct LDKBech32Error a);
57412 export function Bolt11ParseError_bech32_error(a: bigint): bigint {
57413 if(!isWasmInitialized) {
57414 throw new Error("initializeWasm() must be awaited first!");
57416 const nativeResponseValue = wasm.TS_Bolt11ParseError_bech32_error(a);
57417 return nativeResponseValue;
57419 // struct LDKBolt11ParseError Bolt11ParseError_parse_amount_error(struct LDKError a);
57421 export function Bolt11ParseError_parse_amount_error(a: number): bigint {
57422 if(!isWasmInitialized) {
57423 throw new Error("initializeWasm() must be awaited first!");
57425 const nativeResponseValue = wasm.TS_Bolt11ParseError_parse_amount_error(a);
57426 return nativeResponseValue;
57428 // struct LDKBolt11ParseError Bolt11ParseError_malformed_signature(enum LDKSecp256k1Error a);
57430 export function Bolt11ParseError_malformed_signature(a: Secp256k1Error): bigint {
57431 if(!isWasmInitialized) {
57432 throw new Error("initializeWasm() must be awaited first!");
57434 const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_signature(a);
57435 return nativeResponseValue;
57437 // struct LDKBolt11ParseError Bolt11ParseError_bad_prefix(void);
57439 export function Bolt11ParseError_bad_prefix(): bigint {
57440 if(!isWasmInitialized) {
57441 throw new Error("initializeWasm() must be awaited first!");
57443 const nativeResponseValue = wasm.TS_Bolt11ParseError_bad_prefix();
57444 return nativeResponseValue;
57446 // struct LDKBolt11ParseError Bolt11ParseError_unknown_currency(void);
57448 export function Bolt11ParseError_unknown_currency(): bigint {
57449 if(!isWasmInitialized) {
57450 throw new Error("initializeWasm() must be awaited first!");
57452 const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_currency();
57453 return nativeResponseValue;
57455 // struct LDKBolt11ParseError Bolt11ParseError_unknown_si_prefix(void);
57457 export function Bolt11ParseError_unknown_si_prefix(): bigint {
57458 if(!isWasmInitialized) {
57459 throw new Error("initializeWasm() must be awaited first!");
57461 const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_si_prefix();
57462 return nativeResponseValue;
57464 // struct LDKBolt11ParseError Bolt11ParseError_malformed_hrp(void);
57466 export function Bolt11ParseError_malformed_hrp(): bigint {
57467 if(!isWasmInitialized) {
57468 throw new Error("initializeWasm() must be awaited first!");
57470 const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_hrp();
57471 return nativeResponseValue;
57473 // struct LDKBolt11ParseError Bolt11ParseError_too_short_data_part(void);
57475 export function Bolt11ParseError_too_short_data_part(): bigint {
57476 if(!isWasmInitialized) {
57477 throw new Error("initializeWasm() must be awaited first!");
57479 const nativeResponseValue = wasm.TS_Bolt11ParseError_too_short_data_part();
57480 return nativeResponseValue;
57482 // struct LDKBolt11ParseError Bolt11ParseError_unexpected_end_of_tagged_fields(void);
57484 export function Bolt11ParseError_unexpected_end_of_tagged_fields(): bigint {
57485 if(!isWasmInitialized) {
57486 throw new Error("initializeWasm() must be awaited first!");
57488 const nativeResponseValue = wasm.TS_Bolt11ParseError_unexpected_end_of_tagged_fields();
57489 return nativeResponseValue;
57491 // struct LDKBolt11ParseError Bolt11ParseError_description_decode_error(struct LDKError a);
57493 export function Bolt11ParseError_description_decode_error(a: number): bigint {
57494 if(!isWasmInitialized) {
57495 throw new Error("initializeWasm() must be awaited first!");
57497 const nativeResponseValue = wasm.TS_Bolt11ParseError_description_decode_error(a);
57498 return nativeResponseValue;
57500 // struct LDKBolt11ParseError Bolt11ParseError_padding_error(void);
57502 export function Bolt11ParseError_padding_error(): bigint {
57503 if(!isWasmInitialized) {
57504 throw new Error("initializeWasm() must be awaited first!");
57506 const nativeResponseValue = wasm.TS_Bolt11ParseError_padding_error();
57507 return nativeResponseValue;
57509 // struct LDKBolt11ParseError Bolt11ParseError_integer_overflow_error(void);
57511 export function Bolt11ParseError_integer_overflow_error(): bigint {
57512 if(!isWasmInitialized) {
57513 throw new Error("initializeWasm() must be awaited first!");
57515 const nativeResponseValue = wasm.TS_Bolt11ParseError_integer_overflow_error();
57516 return nativeResponseValue;
57518 // struct LDKBolt11ParseError Bolt11ParseError_invalid_seg_wit_program_length(void);
57520 export function Bolt11ParseError_invalid_seg_wit_program_length(): bigint {
57521 if(!isWasmInitialized) {
57522 throw new Error("initializeWasm() must be awaited first!");
57524 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_seg_wit_program_length();
57525 return nativeResponseValue;
57527 // struct LDKBolt11ParseError Bolt11ParseError_invalid_pub_key_hash_length(void);
57529 export function Bolt11ParseError_invalid_pub_key_hash_length(): bigint {
57530 if(!isWasmInitialized) {
57531 throw new Error("initializeWasm() must be awaited first!");
57533 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_pub_key_hash_length();
57534 return nativeResponseValue;
57536 // struct LDKBolt11ParseError Bolt11ParseError_invalid_script_hash_length(void);
57538 export function Bolt11ParseError_invalid_script_hash_length(): bigint {
57539 if(!isWasmInitialized) {
57540 throw new Error("initializeWasm() must be awaited first!");
57542 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_script_hash_length();
57543 return nativeResponseValue;
57545 // struct LDKBolt11ParseError Bolt11ParseError_invalid_recovery_id(void);
57547 export function Bolt11ParseError_invalid_recovery_id(): bigint {
57548 if(!isWasmInitialized) {
57549 throw new Error("initializeWasm() must be awaited first!");
57551 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_recovery_id();
57552 return nativeResponseValue;
57554 // struct LDKBolt11ParseError Bolt11ParseError_invalid_slice_length(struct LDKStr a);
57556 export function Bolt11ParseError_invalid_slice_length(a: number): bigint {
57557 if(!isWasmInitialized) {
57558 throw new Error("initializeWasm() must be awaited first!");
57560 const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_slice_length(a);
57561 return nativeResponseValue;
57563 // struct LDKBolt11ParseError Bolt11ParseError_skip(void);
57565 export function Bolt11ParseError_skip(): bigint {
57566 if(!isWasmInitialized) {
57567 throw new Error("initializeWasm() must be awaited first!");
57569 const nativeResponseValue = wasm.TS_Bolt11ParseError_skip();
57570 return nativeResponseValue;
57572 // bool Bolt11ParseError_eq(const struct LDKBolt11ParseError *NONNULL_PTR a, const struct LDKBolt11ParseError *NONNULL_PTR b);
57574 export function Bolt11ParseError_eq(a: bigint, b: bigint): boolean {
57575 if(!isWasmInitialized) {
57576 throw new Error("initializeWasm() must be awaited first!");
57578 const nativeResponseValue = wasm.TS_Bolt11ParseError_eq(a, b);
57579 return nativeResponseValue;
57581 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
57583 export function ParseOrSemanticError_free(this_ptr: bigint): void {
57584 if(!isWasmInitialized) {
57585 throw new Error("initializeWasm() must be awaited first!");
57587 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
57588 // debug statements here
57590 // uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
57592 export function ParseOrSemanticError_clone_ptr(arg: bigint): bigint {
57593 if(!isWasmInitialized) {
57594 throw new Error("initializeWasm() must be awaited first!");
57596 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
57597 return nativeResponseValue;
57599 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
57601 export function ParseOrSemanticError_clone(orig: bigint): bigint {
57602 if(!isWasmInitialized) {
57603 throw new Error("initializeWasm() must be awaited first!");
57605 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
57606 return nativeResponseValue;
57608 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKBolt11ParseError a);
57610 export function ParseOrSemanticError_parse_error(a: bigint): bigint {
57611 if(!isWasmInitialized) {
57612 throw new Error("initializeWasm() must be awaited first!");
57614 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
57615 return nativeResponseValue;
57617 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKBolt11SemanticError a);
57619 export function ParseOrSemanticError_semantic_error(a: Bolt11SemanticError): bigint {
57620 if(!isWasmInitialized) {
57621 throw new Error("initializeWasm() must be awaited first!");
57623 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
57624 return nativeResponseValue;
57626 // bool ParseOrSemanticError_eq(const struct LDKParseOrSemanticError *NONNULL_PTR a, const struct LDKParseOrSemanticError *NONNULL_PTR b);
57628 export function ParseOrSemanticError_eq(a: bigint, b: bigint): boolean {
57629 if(!isWasmInitialized) {
57630 throw new Error("initializeWasm() must be awaited first!");
57632 const nativeResponseValue = wasm.TS_ParseOrSemanticError_eq(a, b);
57633 return nativeResponseValue;
57635 // void Bolt11Invoice_free(struct LDKBolt11Invoice this_obj);
57637 export function Bolt11Invoice_free(this_obj: bigint): void {
57638 if(!isWasmInitialized) {
57639 throw new Error("initializeWasm() must be awaited first!");
57641 const nativeResponseValue = wasm.TS_Bolt11Invoice_free(this_obj);
57642 // debug statements here
57644 // bool Bolt11Invoice_eq(const struct LDKBolt11Invoice *NONNULL_PTR a, const struct LDKBolt11Invoice *NONNULL_PTR b);
57646 export function Bolt11Invoice_eq(a: bigint, b: bigint): boolean {
57647 if(!isWasmInitialized) {
57648 throw new Error("initializeWasm() must be awaited first!");
57650 const nativeResponseValue = wasm.TS_Bolt11Invoice_eq(a, b);
57651 return nativeResponseValue;
57653 // uint64_t Bolt11Invoice_clone_ptr(LDKBolt11Invoice *NONNULL_PTR arg);
57655 export function Bolt11Invoice_clone_ptr(arg: bigint): bigint {
57656 if(!isWasmInitialized) {
57657 throw new Error("initializeWasm() must be awaited first!");
57659 const nativeResponseValue = wasm.TS_Bolt11Invoice_clone_ptr(arg);
57660 return nativeResponseValue;
57662 // struct LDKBolt11Invoice Bolt11Invoice_clone(const struct LDKBolt11Invoice *NONNULL_PTR orig);
57664 export function Bolt11Invoice_clone(orig: bigint): bigint {
57665 if(!isWasmInitialized) {
57666 throw new Error("initializeWasm() must be awaited first!");
57668 const nativeResponseValue = wasm.TS_Bolt11Invoice_clone(orig);
57669 return nativeResponseValue;
57671 // uint64_t Bolt11Invoice_hash(const struct LDKBolt11Invoice *NONNULL_PTR o);
57673 export function Bolt11Invoice_hash(o: bigint): bigint {
57674 if(!isWasmInitialized) {
57675 throw new Error("initializeWasm() must be awaited first!");
57677 const nativeResponseValue = wasm.TS_Bolt11Invoice_hash(o);
57678 return nativeResponseValue;
57680 // void SignedRawBolt11Invoice_free(struct LDKSignedRawBolt11Invoice this_obj);
57682 export function SignedRawBolt11Invoice_free(this_obj: bigint): void {
57683 if(!isWasmInitialized) {
57684 throw new Error("initializeWasm() must be awaited first!");
57686 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_free(this_obj);
57687 // debug statements here
57689 // bool SignedRawBolt11Invoice_eq(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR a, const struct LDKSignedRawBolt11Invoice *NONNULL_PTR b);
57691 export function SignedRawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
57692 if(!isWasmInitialized) {
57693 throw new Error("initializeWasm() must be awaited first!");
57695 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_eq(a, b);
57696 return nativeResponseValue;
57698 // uint64_t SignedRawBolt11Invoice_clone_ptr(LDKSignedRawBolt11Invoice *NONNULL_PTR arg);
57700 export function SignedRawBolt11Invoice_clone_ptr(arg: bigint): bigint {
57701 if(!isWasmInitialized) {
57702 throw new Error("initializeWasm() must be awaited first!");
57704 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone_ptr(arg);
57705 return nativeResponseValue;
57707 // struct LDKSignedRawBolt11Invoice SignedRawBolt11Invoice_clone(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR orig);
57709 export function SignedRawBolt11Invoice_clone(orig: bigint): bigint {
57710 if(!isWasmInitialized) {
57711 throw new Error("initializeWasm() must be awaited first!");
57713 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone(orig);
57714 return nativeResponseValue;
57716 // uint64_t SignedRawBolt11Invoice_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
57718 export function SignedRawBolt11Invoice_hash(o: bigint): bigint {
57719 if(!isWasmInitialized) {
57720 throw new Error("initializeWasm() must be awaited first!");
57722 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_hash(o);
57723 return nativeResponseValue;
57725 // void RawBolt11Invoice_free(struct LDKRawBolt11Invoice this_obj);
57727 export function RawBolt11Invoice_free(this_obj: bigint): void {
57728 if(!isWasmInitialized) {
57729 throw new Error("initializeWasm() must be awaited first!");
57731 const nativeResponseValue = wasm.TS_RawBolt11Invoice_free(this_obj);
57732 // debug statements here
57734 // struct LDKRawDataPart RawBolt11Invoice_get_data(const struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr);
57736 export function RawBolt11Invoice_get_data(this_ptr: bigint): bigint {
57737 if(!isWasmInitialized) {
57738 throw new Error("initializeWasm() must be awaited first!");
57740 const nativeResponseValue = wasm.TS_RawBolt11Invoice_get_data(this_ptr);
57741 return nativeResponseValue;
57743 // void RawBolt11Invoice_set_data(struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
57745 export function RawBolt11Invoice_set_data(this_ptr: bigint, val: bigint): void {
57746 if(!isWasmInitialized) {
57747 throw new Error("initializeWasm() must be awaited first!");
57749 const nativeResponseValue = wasm.TS_RawBolt11Invoice_set_data(this_ptr, val);
57750 // debug statements here
57752 // bool RawBolt11Invoice_eq(const struct LDKRawBolt11Invoice *NONNULL_PTR a, const struct LDKRawBolt11Invoice *NONNULL_PTR b);
57754 export function RawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
57755 if(!isWasmInitialized) {
57756 throw new Error("initializeWasm() must be awaited first!");
57758 const nativeResponseValue = wasm.TS_RawBolt11Invoice_eq(a, b);
57759 return nativeResponseValue;
57761 // uint64_t RawBolt11Invoice_clone_ptr(LDKRawBolt11Invoice *NONNULL_PTR arg);
57763 export function RawBolt11Invoice_clone_ptr(arg: bigint): bigint {
57764 if(!isWasmInitialized) {
57765 throw new Error("initializeWasm() must be awaited first!");
57767 const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone_ptr(arg);
57768 return nativeResponseValue;
57770 // struct LDKRawBolt11Invoice RawBolt11Invoice_clone(const struct LDKRawBolt11Invoice *NONNULL_PTR orig);
57772 export function RawBolt11Invoice_clone(orig: bigint): bigint {
57773 if(!isWasmInitialized) {
57774 throw new Error("initializeWasm() must be awaited first!");
57776 const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone(orig);
57777 return nativeResponseValue;
57779 // uint64_t RawBolt11Invoice_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR o);
57781 export function RawBolt11Invoice_hash(o: bigint): bigint {
57782 if(!isWasmInitialized) {
57783 throw new Error("initializeWasm() must be awaited first!");
57785 const nativeResponseValue = wasm.TS_RawBolt11Invoice_hash(o);
57786 return nativeResponseValue;
57788 // void RawDataPart_free(struct LDKRawDataPart this_obj);
57790 export function RawDataPart_free(this_obj: bigint): void {
57791 if(!isWasmInitialized) {
57792 throw new Error("initializeWasm() must be awaited first!");
57794 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
57795 // debug statements here
57797 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
57799 export function RawDataPart_get_timestamp(this_ptr: bigint): bigint {
57800 if(!isWasmInitialized) {
57801 throw new Error("initializeWasm() must be awaited first!");
57803 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
57804 return nativeResponseValue;
57806 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
57808 export function RawDataPart_set_timestamp(this_ptr: bigint, val: bigint): void {
57809 if(!isWasmInitialized) {
57810 throw new Error("initializeWasm() must be awaited first!");
57812 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
57813 // debug statements here
57815 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
57817 export function RawDataPart_eq(a: bigint, b: bigint): boolean {
57818 if(!isWasmInitialized) {
57819 throw new Error("initializeWasm() must be awaited first!");
57821 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
57822 return nativeResponseValue;
57824 // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
57826 export function RawDataPart_clone_ptr(arg: bigint): bigint {
57827 if(!isWasmInitialized) {
57828 throw new Error("initializeWasm() must be awaited first!");
57830 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
57831 return nativeResponseValue;
57833 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
57835 export function RawDataPart_clone(orig: bigint): bigint {
57836 if(!isWasmInitialized) {
57837 throw new Error("initializeWasm() must be awaited first!");
57839 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
57840 return nativeResponseValue;
57842 // uint64_t RawDataPart_hash(const struct LDKRawDataPart *NONNULL_PTR o);
57844 export function RawDataPart_hash(o: bigint): bigint {
57845 if(!isWasmInitialized) {
57846 throw new Error("initializeWasm() must be awaited first!");
57848 const nativeResponseValue = wasm.TS_RawDataPart_hash(o);
57849 return nativeResponseValue;
57851 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
57853 export function PositiveTimestamp_free(this_obj: bigint): void {
57854 if(!isWasmInitialized) {
57855 throw new Error("initializeWasm() must be awaited first!");
57857 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
57858 // debug statements here
57860 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
57862 export function PositiveTimestamp_eq(a: bigint, b: bigint): boolean {
57863 if(!isWasmInitialized) {
57864 throw new Error("initializeWasm() must be awaited first!");
57866 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
57867 return nativeResponseValue;
57869 // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
57871 export function PositiveTimestamp_clone_ptr(arg: bigint): bigint {
57872 if(!isWasmInitialized) {
57873 throw new Error("initializeWasm() must be awaited first!");
57875 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
57876 return nativeResponseValue;
57878 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
57880 export function PositiveTimestamp_clone(orig: bigint): bigint {
57881 if(!isWasmInitialized) {
57882 throw new Error("initializeWasm() must be awaited first!");
57884 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
57885 return nativeResponseValue;
57887 // uint64_t PositiveTimestamp_hash(const struct LDKPositiveTimestamp *NONNULL_PTR o);
57889 export function PositiveTimestamp_hash(o: bigint): bigint {
57890 if(!isWasmInitialized) {
57891 throw new Error("initializeWasm() must be awaited first!");
57893 const nativeResponseValue = wasm.TS_PositiveTimestamp_hash(o);
57894 return nativeResponseValue;
57896 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
57898 export function SiPrefix_clone(orig: bigint): SiPrefix {
57899 if(!isWasmInitialized) {
57900 throw new Error("initializeWasm() must be awaited first!");
57902 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
57903 return nativeResponseValue;
57905 // enum LDKSiPrefix SiPrefix_milli(void);
57907 export function SiPrefix_milli(): SiPrefix {
57908 if(!isWasmInitialized) {
57909 throw new Error("initializeWasm() must be awaited first!");
57911 const nativeResponseValue = wasm.TS_SiPrefix_milli();
57912 return nativeResponseValue;
57914 // enum LDKSiPrefix SiPrefix_micro(void);
57916 export function SiPrefix_micro(): SiPrefix {
57917 if(!isWasmInitialized) {
57918 throw new Error("initializeWasm() must be awaited first!");
57920 const nativeResponseValue = wasm.TS_SiPrefix_micro();
57921 return nativeResponseValue;
57923 // enum LDKSiPrefix SiPrefix_nano(void);
57925 export function SiPrefix_nano(): SiPrefix {
57926 if(!isWasmInitialized) {
57927 throw new Error("initializeWasm() must be awaited first!");
57929 const nativeResponseValue = wasm.TS_SiPrefix_nano();
57930 return nativeResponseValue;
57932 // enum LDKSiPrefix SiPrefix_pico(void);
57934 export function SiPrefix_pico(): SiPrefix {
57935 if(!isWasmInitialized) {
57936 throw new Error("initializeWasm() must be awaited first!");
57938 const nativeResponseValue = wasm.TS_SiPrefix_pico();
57939 return nativeResponseValue;
57941 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
57943 export function SiPrefix_eq(a: bigint, b: bigint): boolean {
57944 if(!isWasmInitialized) {
57945 throw new Error("initializeWasm() must be awaited first!");
57947 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
57948 return nativeResponseValue;
57950 // uint64_t SiPrefix_hash(const enum LDKSiPrefix *NONNULL_PTR o);
57952 export function SiPrefix_hash(o: bigint): bigint {
57953 if(!isWasmInitialized) {
57954 throw new Error("initializeWasm() must be awaited first!");
57956 const nativeResponseValue = wasm.TS_SiPrefix_hash(o);
57957 return nativeResponseValue;
57959 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
57961 export function SiPrefix_multiplier(this_arg: bigint): bigint {
57962 if(!isWasmInitialized) {
57963 throw new Error("initializeWasm() must be awaited first!");
57965 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
57966 return nativeResponseValue;
57968 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
57970 export function Currency_clone(orig: bigint): Currency {
57971 if(!isWasmInitialized) {
57972 throw new Error("initializeWasm() must be awaited first!");
57974 const nativeResponseValue = wasm.TS_Currency_clone(orig);
57975 return nativeResponseValue;
57977 // enum LDKCurrency Currency_bitcoin(void);
57979 export function Currency_bitcoin(): Currency {
57980 if(!isWasmInitialized) {
57981 throw new Error("initializeWasm() must be awaited first!");
57983 const nativeResponseValue = wasm.TS_Currency_bitcoin();
57984 return nativeResponseValue;
57986 // enum LDKCurrency Currency_bitcoin_testnet(void);
57988 export function Currency_bitcoin_testnet(): Currency {
57989 if(!isWasmInitialized) {
57990 throw new Error("initializeWasm() must be awaited first!");
57992 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
57993 return nativeResponseValue;
57995 // enum LDKCurrency Currency_regtest(void);
57997 export function Currency_regtest(): Currency {
57998 if(!isWasmInitialized) {
57999 throw new Error("initializeWasm() must be awaited first!");
58001 const nativeResponseValue = wasm.TS_Currency_regtest();
58002 return nativeResponseValue;
58004 // enum LDKCurrency Currency_simnet(void);
58006 export function Currency_simnet(): Currency {
58007 if(!isWasmInitialized) {
58008 throw new Error("initializeWasm() must be awaited first!");
58010 const nativeResponseValue = wasm.TS_Currency_simnet();
58011 return nativeResponseValue;
58013 // enum LDKCurrency Currency_signet(void);
58015 export function Currency_signet(): Currency {
58016 if(!isWasmInitialized) {
58017 throw new Error("initializeWasm() must be awaited first!");
58019 const nativeResponseValue = wasm.TS_Currency_signet();
58020 return nativeResponseValue;
58022 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
58024 export function Currency_hash(o: bigint): bigint {
58025 if(!isWasmInitialized) {
58026 throw new Error("initializeWasm() must be awaited first!");
58028 const nativeResponseValue = wasm.TS_Currency_hash(o);
58029 return nativeResponseValue;
58031 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
58033 export function Currency_eq(a: bigint, b: bigint): boolean {
58034 if(!isWasmInitialized) {
58035 throw new Error("initializeWasm() must be awaited first!");
58037 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
58038 return nativeResponseValue;
58040 // void Sha256_free(struct LDKSha256 this_obj);
58042 export function Sha256_free(this_obj: bigint): void {
58043 if(!isWasmInitialized) {
58044 throw new Error("initializeWasm() must be awaited first!");
58046 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
58047 // debug statements here
58049 // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
58051 export function Sha256_clone_ptr(arg: bigint): bigint {
58052 if(!isWasmInitialized) {
58053 throw new Error("initializeWasm() must be awaited first!");
58055 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
58056 return nativeResponseValue;
58058 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
58060 export function Sha256_clone(orig: bigint): bigint {
58061 if(!isWasmInitialized) {
58062 throw new Error("initializeWasm() must be awaited first!");
58064 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
58065 return nativeResponseValue;
58067 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
58069 export function Sha256_hash(o: bigint): bigint {
58070 if(!isWasmInitialized) {
58071 throw new Error("initializeWasm() must be awaited first!");
58073 const nativeResponseValue = wasm.TS_Sha256_hash(o);
58074 return nativeResponseValue;
58076 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
58078 export function Sha256_eq(a: bigint, b: bigint): boolean {
58079 if(!isWasmInitialized) {
58080 throw new Error("initializeWasm() must be awaited first!");
58082 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
58083 return nativeResponseValue;
58085 // MUST_USE_RES struct LDKSha256 Sha256_from_bytes(const uint8_t (*bytes)[32]);
58087 export function Sha256_from_bytes(bytes: number): bigint {
58088 if(!isWasmInitialized) {
58089 throw new Error("initializeWasm() must be awaited first!");
58091 const nativeResponseValue = wasm.TS_Sha256_from_bytes(bytes);
58092 return nativeResponseValue;
58094 // void Description_free(struct LDKDescription this_obj);
58096 export function Description_free(this_obj: bigint): void {
58097 if(!isWasmInitialized) {
58098 throw new Error("initializeWasm() must be awaited first!");
58100 const nativeResponseValue = wasm.TS_Description_free(this_obj);
58101 // debug statements here
58103 // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
58105 export function Description_clone_ptr(arg: bigint): bigint {
58106 if(!isWasmInitialized) {
58107 throw new Error("initializeWasm() must be awaited first!");
58109 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
58110 return nativeResponseValue;
58112 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
58114 export function Description_clone(orig: bigint): bigint {
58115 if(!isWasmInitialized) {
58116 throw new Error("initializeWasm() must be awaited first!");
58118 const nativeResponseValue = wasm.TS_Description_clone(orig);
58119 return nativeResponseValue;
58121 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
58123 export function Description_hash(o: bigint): bigint {
58124 if(!isWasmInitialized) {
58125 throw new Error("initializeWasm() must be awaited first!");
58127 const nativeResponseValue = wasm.TS_Description_hash(o);
58128 return nativeResponseValue;
58130 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
58132 export function Description_eq(a: bigint, b: bigint): boolean {
58133 if(!isWasmInitialized) {
58134 throw new Error("initializeWasm() must be awaited first!");
58136 const nativeResponseValue = wasm.TS_Description_eq(a, b);
58137 return nativeResponseValue;
58139 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
58141 export function PayeePubKey_free(this_obj: bigint): void {
58142 if(!isWasmInitialized) {
58143 throw new Error("initializeWasm() must be awaited first!");
58145 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
58146 // debug statements here
58148 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
58150 export function PayeePubKey_get_a(this_ptr: bigint): number {
58151 if(!isWasmInitialized) {
58152 throw new Error("initializeWasm() must be awaited first!");
58154 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
58155 return nativeResponseValue;
58157 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
58159 export function PayeePubKey_set_a(this_ptr: bigint, val: number): void {
58160 if(!isWasmInitialized) {
58161 throw new Error("initializeWasm() must be awaited first!");
58163 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
58164 // debug statements here
58166 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
58168 export function PayeePubKey_new(a_arg: number): bigint {
58169 if(!isWasmInitialized) {
58170 throw new Error("initializeWasm() must be awaited first!");
58172 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
58173 return nativeResponseValue;
58175 // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
58177 export function PayeePubKey_clone_ptr(arg: bigint): bigint {
58178 if(!isWasmInitialized) {
58179 throw new Error("initializeWasm() must be awaited first!");
58181 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
58182 return nativeResponseValue;
58184 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
58186 export function PayeePubKey_clone(orig: bigint): bigint {
58187 if(!isWasmInitialized) {
58188 throw new Error("initializeWasm() must be awaited first!");
58190 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
58191 return nativeResponseValue;
58193 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
58195 export function PayeePubKey_hash(o: bigint): bigint {
58196 if(!isWasmInitialized) {
58197 throw new Error("initializeWasm() must be awaited first!");
58199 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
58200 return nativeResponseValue;
58202 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
58204 export function PayeePubKey_eq(a: bigint, b: bigint): boolean {
58205 if(!isWasmInitialized) {
58206 throw new Error("initializeWasm() must be awaited first!");
58208 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
58209 return nativeResponseValue;
58211 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
58213 export function ExpiryTime_free(this_obj: bigint): void {
58214 if(!isWasmInitialized) {
58215 throw new Error("initializeWasm() must be awaited first!");
58217 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
58218 // debug statements here
58220 // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
58222 export function ExpiryTime_clone_ptr(arg: bigint): bigint {
58223 if(!isWasmInitialized) {
58224 throw new Error("initializeWasm() must be awaited first!");
58226 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
58227 return nativeResponseValue;
58229 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
58231 export function ExpiryTime_clone(orig: bigint): bigint {
58232 if(!isWasmInitialized) {
58233 throw new Error("initializeWasm() must be awaited first!");
58235 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
58236 return nativeResponseValue;
58238 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
58240 export function ExpiryTime_hash(o: bigint): bigint {
58241 if(!isWasmInitialized) {
58242 throw new Error("initializeWasm() must be awaited first!");
58244 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
58245 return nativeResponseValue;
58247 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
58249 export function ExpiryTime_eq(a: bigint, b: bigint): boolean {
58250 if(!isWasmInitialized) {
58251 throw new Error("initializeWasm() must be awaited first!");
58253 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
58254 return nativeResponseValue;
58256 // void MinFinalCltvExpiryDelta_free(struct LDKMinFinalCltvExpiryDelta this_obj);
58258 export function MinFinalCltvExpiryDelta_free(this_obj: bigint): void {
58259 if(!isWasmInitialized) {
58260 throw new Error("initializeWasm() must be awaited first!");
58262 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_free(this_obj);
58263 // debug statements here
58265 // uint64_t MinFinalCltvExpiryDelta_get_a(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr);
58267 export function MinFinalCltvExpiryDelta_get_a(this_ptr: bigint): bigint {
58268 if(!isWasmInitialized) {
58269 throw new Error("initializeWasm() must be awaited first!");
58271 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_get_a(this_ptr);
58272 return nativeResponseValue;
58274 // void MinFinalCltvExpiryDelta_set_a(struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr, uint64_t val);
58276 export function MinFinalCltvExpiryDelta_set_a(this_ptr: bigint, val: bigint): void {
58277 if(!isWasmInitialized) {
58278 throw new Error("initializeWasm() must be awaited first!");
58280 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_set_a(this_ptr, val);
58281 // debug statements here
58283 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_new(uint64_t a_arg);
58285 export function MinFinalCltvExpiryDelta_new(a_arg: bigint): bigint {
58286 if(!isWasmInitialized) {
58287 throw new Error("initializeWasm() must be awaited first!");
58289 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_new(a_arg);
58290 return nativeResponseValue;
58292 // uint64_t MinFinalCltvExpiryDelta_clone_ptr(LDKMinFinalCltvExpiryDelta *NONNULL_PTR arg);
58294 export function MinFinalCltvExpiryDelta_clone_ptr(arg: bigint): bigint {
58295 if(!isWasmInitialized) {
58296 throw new Error("initializeWasm() must be awaited first!");
58298 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone_ptr(arg);
58299 return nativeResponseValue;
58301 // struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_clone(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR orig);
58303 export function MinFinalCltvExpiryDelta_clone(orig: bigint): bigint {
58304 if(!isWasmInitialized) {
58305 throw new Error("initializeWasm() must be awaited first!");
58307 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone(orig);
58308 return nativeResponseValue;
58310 // uint64_t MinFinalCltvExpiryDelta_hash(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR o);
58312 export function MinFinalCltvExpiryDelta_hash(o: bigint): bigint {
58313 if(!isWasmInitialized) {
58314 throw new Error("initializeWasm() must be awaited first!");
58316 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_hash(o);
58317 return nativeResponseValue;
58319 // bool MinFinalCltvExpiryDelta_eq(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR a, const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR b);
58321 export function MinFinalCltvExpiryDelta_eq(a: bigint, b: bigint): boolean {
58322 if(!isWasmInitialized) {
58323 throw new Error("initializeWasm() must be awaited first!");
58325 const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_eq(a, b);
58326 return nativeResponseValue;
58328 // void Fallback_free(struct LDKFallback this_ptr);
58330 export function Fallback_free(this_ptr: bigint): void {
58331 if(!isWasmInitialized) {
58332 throw new Error("initializeWasm() must be awaited first!");
58334 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
58335 // debug statements here
58337 // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
58339 export function Fallback_clone_ptr(arg: bigint): bigint {
58340 if(!isWasmInitialized) {
58341 throw new Error("initializeWasm() must be awaited first!");
58343 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
58344 return nativeResponseValue;
58346 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
58348 export function Fallback_clone(orig: bigint): bigint {
58349 if(!isWasmInitialized) {
58350 throw new Error("initializeWasm() must be awaited first!");
58352 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
58353 return nativeResponseValue;
58355 // struct LDKFallback Fallback_seg_wit_program(struct LDKWitnessVersion version, struct LDKCVec_u8Z program);
58357 export function Fallback_seg_wit_program(version: number, program: number): bigint {
58358 if(!isWasmInitialized) {
58359 throw new Error("initializeWasm() must be awaited first!");
58361 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
58362 return nativeResponseValue;
58364 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
58366 export function Fallback_pub_key_hash(a: number): bigint {
58367 if(!isWasmInitialized) {
58368 throw new Error("initializeWasm() must be awaited first!");
58370 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
58371 return nativeResponseValue;
58373 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
58375 export function Fallback_script_hash(a: number): bigint {
58376 if(!isWasmInitialized) {
58377 throw new Error("initializeWasm() must be awaited first!");
58379 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
58380 return nativeResponseValue;
58382 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
58384 export function Fallback_hash(o: bigint): bigint {
58385 if(!isWasmInitialized) {
58386 throw new Error("initializeWasm() must be awaited first!");
58388 const nativeResponseValue = wasm.TS_Fallback_hash(o);
58389 return nativeResponseValue;
58391 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
58393 export function Fallback_eq(a: bigint, b: bigint): boolean {
58394 if(!isWasmInitialized) {
58395 throw new Error("initializeWasm() must be awaited first!");
58397 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
58398 return nativeResponseValue;
58400 // void Bolt11InvoiceSignature_free(struct LDKBolt11InvoiceSignature this_obj);
58402 export function Bolt11InvoiceSignature_free(this_obj: bigint): void {
58403 if(!isWasmInitialized) {
58404 throw new Error("initializeWasm() must be awaited first!");
58406 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_free(this_obj);
58407 // debug statements here
58409 // uint64_t Bolt11InvoiceSignature_clone_ptr(LDKBolt11InvoiceSignature *NONNULL_PTR arg);
58411 export function Bolt11InvoiceSignature_clone_ptr(arg: bigint): bigint {
58412 if(!isWasmInitialized) {
58413 throw new Error("initializeWasm() must be awaited first!");
58415 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone_ptr(arg);
58416 return nativeResponseValue;
58418 // struct LDKBolt11InvoiceSignature Bolt11InvoiceSignature_clone(const struct LDKBolt11InvoiceSignature *NONNULL_PTR orig);
58420 export function Bolt11InvoiceSignature_clone(orig: bigint): bigint {
58421 if(!isWasmInitialized) {
58422 throw new Error("initializeWasm() must be awaited first!");
58424 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone(orig);
58425 return nativeResponseValue;
58427 // uint64_t Bolt11InvoiceSignature_hash(const struct LDKBolt11InvoiceSignature *NONNULL_PTR o);
58429 export function Bolt11InvoiceSignature_hash(o: bigint): bigint {
58430 if(!isWasmInitialized) {
58431 throw new Error("initializeWasm() must be awaited first!");
58433 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_hash(o);
58434 return nativeResponseValue;
58436 // bool Bolt11InvoiceSignature_eq(const struct LDKBolt11InvoiceSignature *NONNULL_PTR a, const struct LDKBolt11InvoiceSignature *NONNULL_PTR b);
58438 export function Bolt11InvoiceSignature_eq(a: bigint, b: bigint): boolean {
58439 if(!isWasmInitialized) {
58440 throw new Error("initializeWasm() must be awaited first!");
58442 const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_eq(a, b);
58443 return nativeResponseValue;
58445 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
58447 export function PrivateRoute_free(this_obj: bigint): void {
58448 if(!isWasmInitialized) {
58449 throw new Error("initializeWasm() must be awaited first!");
58451 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
58452 // debug statements here
58454 // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
58456 export function PrivateRoute_clone_ptr(arg: bigint): bigint {
58457 if(!isWasmInitialized) {
58458 throw new Error("initializeWasm() must be awaited first!");
58460 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
58461 return nativeResponseValue;
58463 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
58465 export function PrivateRoute_clone(orig: bigint): bigint {
58466 if(!isWasmInitialized) {
58467 throw new Error("initializeWasm() must be awaited first!");
58469 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
58470 return nativeResponseValue;
58472 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
58474 export function PrivateRoute_hash(o: bigint): bigint {
58475 if(!isWasmInitialized) {
58476 throw new Error("initializeWasm() must be awaited first!");
58478 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
58479 return nativeResponseValue;
58481 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
58483 export function PrivateRoute_eq(a: bigint, b: bigint): boolean {
58484 if(!isWasmInitialized) {
58485 throw new Error("initializeWasm() must be awaited first!");
58487 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
58488 return nativeResponseValue;
58490 // MUST_USE_RES struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ SignedRawBolt11Invoice_into_parts(struct LDKSignedRawBolt11Invoice this_arg);
58492 export function SignedRawBolt11Invoice_into_parts(this_arg: bigint): bigint {
58493 if(!isWasmInitialized) {
58494 throw new Error("initializeWasm() must be awaited first!");
58496 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_into_parts(this_arg);
58497 return nativeResponseValue;
58499 // MUST_USE_RES struct LDKRawBolt11Invoice SignedRawBolt11Invoice_raw_invoice(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
58501 export function SignedRawBolt11Invoice_raw_invoice(this_arg: bigint): bigint {
58502 if(!isWasmInitialized) {
58503 throw new Error("initializeWasm() must be awaited first!");
58505 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_raw_invoice(this_arg);
58506 return nativeResponseValue;
58508 // MUST_USE_RES const uint8_t (*SignedRawBolt11Invoice_signable_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg))[32];
58510 export function SignedRawBolt11Invoice_signable_hash(this_arg: bigint): number {
58511 if(!isWasmInitialized) {
58512 throw new Error("initializeWasm() must be awaited first!");
58514 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signable_hash(this_arg);
58515 return nativeResponseValue;
58517 // MUST_USE_RES struct LDKBolt11InvoiceSignature SignedRawBolt11Invoice_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
58519 export function SignedRawBolt11Invoice_signature(this_arg: bigint): bigint {
58520 if(!isWasmInitialized) {
58521 throw new Error("initializeWasm() must be awaited first!");
58523 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signature(this_arg);
58524 return nativeResponseValue;
58526 // MUST_USE_RES struct LDKCResult_PayeePubKeySecp256k1ErrorZ SignedRawBolt11Invoice_recover_payee_pub_key(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
58528 export function SignedRawBolt11Invoice_recover_payee_pub_key(this_arg: bigint): bigint {
58529 if(!isWasmInitialized) {
58530 throw new Error("initializeWasm() must be awaited first!");
58532 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_recover_payee_pub_key(this_arg);
58533 return nativeResponseValue;
58535 // MUST_USE_RES bool SignedRawBolt11Invoice_check_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
58537 export function SignedRawBolt11Invoice_check_signature(this_arg: bigint): boolean {
58538 if(!isWasmInitialized) {
58539 throw new Error("initializeWasm() must be awaited first!");
58541 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_check_signature(this_arg);
58542 return nativeResponseValue;
58544 // MUST_USE_RES struct LDKThirtyTwoBytes RawBolt11Invoice_signable_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58546 export function RawBolt11Invoice_signable_hash(this_arg: bigint): number {
58547 if(!isWasmInitialized) {
58548 throw new Error("initializeWasm() must be awaited first!");
58550 const nativeResponseValue = wasm.TS_RawBolt11Invoice_signable_hash(this_arg);
58551 return nativeResponseValue;
58553 // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_payment_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58555 export function RawBolt11Invoice_payment_hash(this_arg: bigint): bigint {
58556 if(!isWasmInitialized) {
58557 throw new Error("initializeWasm() must be awaited first!");
58559 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_hash(this_arg);
58560 return nativeResponseValue;
58562 // MUST_USE_RES struct LDKDescription RawBolt11Invoice_description(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58564 export function RawBolt11Invoice_description(this_arg: bigint): bigint {
58565 if(!isWasmInitialized) {
58566 throw new Error("initializeWasm() must be awaited first!");
58568 const nativeResponseValue = wasm.TS_RawBolt11Invoice_description(this_arg);
58569 return nativeResponseValue;
58571 // MUST_USE_RES struct LDKPayeePubKey RawBolt11Invoice_payee_pub_key(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58573 export function RawBolt11Invoice_payee_pub_key(this_arg: bigint): bigint {
58574 if(!isWasmInitialized) {
58575 throw new Error("initializeWasm() must be awaited first!");
58577 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payee_pub_key(this_arg);
58578 return nativeResponseValue;
58580 // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_description_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58582 export function RawBolt11Invoice_description_hash(this_arg: bigint): bigint {
58583 if(!isWasmInitialized) {
58584 throw new Error("initializeWasm() must be awaited first!");
58586 const nativeResponseValue = wasm.TS_RawBolt11Invoice_description_hash(this_arg);
58587 return nativeResponseValue;
58589 // MUST_USE_RES struct LDKExpiryTime RawBolt11Invoice_expiry_time(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58591 export function RawBolt11Invoice_expiry_time(this_arg: bigint): bigint {
58592 if(!isWasmInitialized) {
58593 throw new Error("initializeWasm() must be awaited first!");
58595 const nativeResponseValue = wasm.TS_RawBolt11Invoice_expiry_time(this_arg);
58596 return nativeResponseValue;
58598 // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta RawBolt11Invoice_min_final_cltv_expiry_delta(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58600 export function RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
58601 if(!isWasmInitialized) {
58602 throw new Error("initializeWasm() must be awaited first!");
58604 const nativeResponseValue = wasm.TS_RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg);
58605 return nativeResponseValue;
58607 // MUST_USE_RES struct LDKCOption_ThirtyTwoBytesZ RawBolt11Invoice_payment_secret(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58609 export function RawBolt11Invoice_payment_secret(this_arg: bigint): bigint {
58610 if(!isWasmInitialized) {
58611 throw new Error("initializeWasm() must be awaited first!");
58613 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_secret(this_arg);
58614 return nativeResponseValue;
58616 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ RawBolt11Invoice_payment_metadata(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58618 export function RawBolt11Invoice_payment_metadata(this_arg: bigint): bigint {
58619 if(!isWasmInitialized) {
58620 throw new Error("initializeWasm() must be awaited first!");
58622 const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_metadata(this_arg);
58623 return nativeResponseValue;
58625 // MUST_USE_RES struct LDKBolt11InvoiceFeatures RawBolt11Invoice_features(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58627 export function RawBolt11Invoice_features(this_arg: bigint): bigint {
58628 if(!isWasmInitialized) {
58629 throw new Error("initializeWasm() must be awaited first!");
58631 const nativeResponseValue = wasm.TS_RawBolt11Invoice_features(this_arg);
58632 return nativeResponseValue;
58634 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawBolt11Invoice_private_routes(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58636 export function RawBolt11Invoice_private_routes(this_arg: bigint): number {
58637 if(!isWasmInitialized) {
58638 throw new Error("initializeWasm() must be awaited first!");
58640 const nativeResponseValue = wasm.TS_RawBolt11Invoice_private_routes(this_arg);
58641 return nativeResponseValue;
58643 // MUST_USE_RES struct LDKCOption_u64Z RawBolt11Invoice_amount_pico_btc(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58645 export function RawBolt11Invoice_amount_pico_btc(this_arg: bigint): bigint {
58646 if(!isWasmInitialized) {
58647 throw new Error("initializeWasm() must be awaited first!");
58649 const nativeResponseValue = wasm.TS_RawBolt11Invoice_amount_pico_btc(this_arg);
58650 return nativeResponseValue;
58652 // MUST_USE_RES enum LDKCurrency RawBolt11Invoice_currency(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
58654 export function RawBolt11Invoice_currency(this_arg: bigint): Currency {
58655 if(!isWasmInitialized) {
58656 throw new Error("initializeWasm() must be awaited first!");
58658 const nativeResponseValue = wasm.TS_RawBolt11Invoice_currency(this_arg);
58659 return nativeResponseValue;
58661 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
58663 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): bigint {
58664 if(!isWasmInitialized) {
58665 throw new Error("initializeWasm() must be awaited first!");
58667 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
58668 return nativeResponseValue;
58670 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
58672 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): bigint {
58673 if(!isWasmInitialized) {
58674 throw new Error("initializeWasm() must be awaited first!");
58676 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
58677 return nativeResponseValue;
58679 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
58681 export function PositiveTimestamp_as_unix_timestamp(this_arg: bigint): bigint {
58682 if(!isWasmInitialized) {
58683 throw new Error("initializeWasm() must be awaited first!");
58685 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
58686 return nativeResponseValue;
58688 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
58690 export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): bigint {
58691 if(!isWasmInitialized) {
58692 throw new Error("initializeWasm() must be awaited first!");
58694 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
58695 return nativeResponseValue;
58697 // MUST_USE_RES struct LDKThirtyTwoBytes Bolt11Invoice_signable_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58699 export function Bolt11Invoice_signable_hash(this_arg: bigint): number {
58700 if(!isWasmInitialized) {
58701 throw new Error("initializeWasm() must be awaited first!");
58703 const nativeResponseValue = wasm.TS_Bolt11Invoice_signable_hash(this_arg);
58704 return nativeResponseValue;
58706 // MUST_USE_RES struct LDKSignedRawBolt11Invoice Bolt11Invoice_into_signed_raw(struct LDKBolt11Invoice this_arg);
58708 export function Bolt11Invoice_into_signed_raw(this_arg: bigint): bigint {
58709 if(!isWasmInitialized) {
58710 throw new Error("initializeWasm() must be awaited first!");
58712 const nativeResponseValue = wasm.TS_Bolt11Invoice_into_signed_raw(this_arg);
58713 return nativeResponseValue;
58715 // MUST_USE_RES struct LDKCResult_NoneBolt11SemanticErrorZ Bolt11Invoice_check_signature(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58717 export function Bolt11Invoice_check_signature(this_arg: bigint): bigint {
58718 if(!isWasmInitialized) {
58719 throw new Error("initializeWasm() must be awaited first!");
58721 const nativeResponseValue = wasm.TS_Bolt11Invoice_check_signature(this_arg);
58722 return nativeResponseValue;
58724 // MUST_USE_RES struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ Bolt11Invoice_from_signed(struct LDKSignedRawBolt11Invoice signed_invoice);
58726 export function Bolt11Invoice_from_signed(signed_invoice: bigint): bigint {
58727 if(!isWasmInitialized) {
58728 throw new Error("initializeWasm() must be awaited first!");
58730 const nativeResponseValue = wasm.TS_Bolt11Invoice_from_signed(signed_invoice);
58731 return nativeResponseValue;
58733 // MUST_USE_RES uint64_t Bolt11Invoice_duration_since_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58735 export function Bolt11Invoice_duration_since_epoch(this_arg: bigint): bigint {
58736 if(!isWasmInitialized) {
58737 throw new Error("initializeWasm() must be awaited first!");
58739 const nativeResponseValue = wasm.TS_Bolt11Invoice_duration_since_epoch(this_arg);
58740 return nativeResponseValue;
58742 // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
58744 export function Bolt11Invoice_payment_hash(this_arg: bigint): number {
58745 if(!isWasmInitialized) {
58746 throw new Error("initializeWasm() must be awaited first!");
58748 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_hash(this_arg);
58749 return nativeResponseValue;
58751 // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58753 export function Bolt11Invoice_payee_pub_key(this_arg: bigint): number {
58754 if(!isWasmInitialized) {
58755 throw new Error("initializeWasm() must be awaited first!");
58757 const nativeResponseValue = wasm.TS_Bolt11Invoice_payee_pub_key(this_arg);
58758 return nativeResponseValue;
58760 // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_secret(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
58762 export function Bolt11Invoice_payment_secret(this_arg: bigint): number {
58763 if(!isWasmInitialized) {
58764 throw new Error("initializeWasm() must be awaited first!");
58766 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_secret(this_arg);
58767 return nativeResponseValue;
58769 // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Bolt11Invoice_payment_metadata(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58771 export function Bolt11Invoice_payment_metadata(this_arg: bigint): bigint {
58772 if(!isWasmInitialized) {
58773 throw new Error("initializeWasm() must be awaited first!");
58775 const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_metadata(this_arg);
58776 return nativeResponseValue;
58778 // MUST_USE_RES struct LDKBolt11InvoiceFeatures Bolt11Invoice_features(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58780 export function Bolt11Invoice_features(this_arg: bigint): bigint {
58781 if(!isWasmInitialized) {
58782 throw new Error("initializeWasm() must be awaited first!");
58784 const nativeResponseValue = wasm.TS_Bolt11Invoice_features(this_arg);
58785 return nativeResponseValue;
58787 // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_recover_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58789 export function Bolt11Invoice_recover_payee_pub_key(this_arg: bigint): number {
58790 if(!isWasmInitialized) {
58791 throw new Error("initializeWasm() must be awaited first!");
58793 const nativeResponseValue = wasm.TS_Bolt11Invoice_recover_payee_pub_key(this_arg);
58794 return nativeResponseValue;
58796 // MUST_USE_RES struct LDKCOption_u64Z Bolt11Invoice_expires_at(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58798 export function Bolt11Invoice_expires_at(this_arg: bigint): bigint {
58799 if(!isWasmInitialized) {
58800 throw new Error("initializeWasm() must be awaited first!");
58802 const nativeResponseValue = wasm.TS_Bolt11Invoice_expires_at(this_arg);
58803 return nativeResponseValue;
58805 // MUST_USE_RES uint64_t Bolt11Invoice_expiry_time(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58807 export function Bolt11Invoice_expiry_time(this_arg: bigint): bigint {
58808 if(!isWasmInitialized) {
58809 throw new Error("initializeWasm() must be awaited first!");
58811 const nativeResponseValue = wasm.TS_Bolt11Invoice_expiry_time(this_arg);
58812 return nativeResponseValue;
58814 // MUST_USE_RES uint64_t Bolt11Invoice_expiration_remaining_from_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t time);
58816 export function Bolt11Invoice_expiration_remaining_from_epoch(this_arg: bigint, time: bigint): bigint {
58817 if(!isWasmInitialized) {
58818 throw new Error("initializeWasm() must be awaited first!");
58820 const nativeResponseValue = wasm.TS_Bolt11Invoice_expiration_remaining_from_epoch(this_arg, time);
58821 return nativeResponseValue;
58823 // MUST_USE_RES bool Bolt11Invoice_would_expire(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t at_time);
58825 export function Bolt11Invoice_would_expire(this_arg: bigint, at_time: bigint): boolean {
58826 if(!isWasmInitialized) {
58827 throw new Error("initializeWasm() must be awaited first!");
58829 const nativeResponseValue = wasm.TS_Bolt11Invoice_would_expire(this_arg, at_time);
58830 return nativeResponseValue;
58832 // MUST_USE_RES uint64_t Bolt11Invoice_min_final_cltv_expiry_delta(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58834 export function Bolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
58835 if(!isWasmInitialized) {
58836 throw new Error("initializeWasm() must be awaited first!");
58838 const nativeResponseValue = wasm.TS_Bolt11Invoice_min_final_cltv_expiry_delta(this_arg);
58839 return nativeResponseValue;
58841 // MUST_USE_RES struct LDKCVec_StrZ Bolt11Invoice_fallback_addresses(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58843 export function Bolt11Invoice_fallback_addresses(this_arg: bigint): number {
58844 if(!isWasmInitialized) {
58845 throw new Error("initializeWasm() must be awaited first!");
58847 const nativeResponseValue = wasm.TS_Bolt11Invoice_fallback_addresses(this_arg);
58848 return nativeResponseValue;
58850 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Bolt11Invoice_private_routes(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58852 export function Bolt11Invoice_private_routes(this_arg: bigint): number {
58853 if(!isWasmInitialized) {
58854 throw new Error("initializeWasm() must be awaited first!");
58856 const nativeResponseValue = wasm.TS_Bolt11Invoice_private_routes(this_arg);
58857 return nativeResponseValue;
58859 // MUST_USE_RES struct LDKCVec_RouteHintZ Bolt11Invoice_route_hints(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58861 export function Bolt11Invoice_route_hints(this_arg: bigint): number {
58862 if(!isWasmInitialized) {
58863 throw new Error("initializeWasm() must be awaited first!");
58865 const nativeResponseValue = wasm.TS_Bolt11Invoice_route_hints(this_arg);
58866 return nativeResponseValue;
58868 // MUST_USE_RES enum LDKCurrency Bolt11Invoice_currency(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58870 export function Bolt11Invoice_currency(this_arg: bigint): Currency {
58871 if(!isWasmInitialized) {
58872 throw new Error("initializeWasm() must be awaited first!");
58874 const nativeResponseValue = wasm.TS_Bolt11Invoice_currency(this_arg);
58875 return nativeResponseValue;
58877 // MUST_USE_RES struct LDKCOption_u64Z Bolt11Invoice_amount_milli_satoshis(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
58879 export function Bolt11Invoice_amount_milli_satoshis(this_arg: bigint): bigint {
58880 if(!isWasmInitialized) {
58881 throw new Error("initializeWasm() must be awaited first!");
58883 const nativeResponseValue = wasm.TS_Bolt11Invoice_amount_milli_satoshis(this_arg);
58884 return nativeResponseValue;
58886 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
58888 export function Description_new(description: number): bigint {
58889 if(!isWasmInitialized) {
58890 throw new Error("initializeWasm() must be awaited first!");
58892 const nativeResponseValue = wasm.TS_Description_new(description);
58893 return nativeResponseValue;
58895 // MUST_USE_RES struct LDKUntrustedString Description_into_inner(struct LDKDescription this_arg);
58897 export function Description_into_inner(this_arg: bigint): bigint {
58898 if(!isWasmInitialized) {
58899 throw new Error("initializeWasm() must be awaited first!");
58901 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
58902 return nativeResponseValue;
58904 // struct LDKStr Description_to_str(const struct LDKDescription *NONNULL_PTR o);
58906 export function Description_to_str(o: bigint): number {
58907 if(!isWasmInitialized) {
58908 throw new Error("initializeWasm() must be awaited first!");
58910 const nativeResponseValue = wasm.TS_Description_to_str(o);
58911 return nativeResponseValue;
58913 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
58915 export function ExpiryTime_from_seconds(seconds: bigint): bigint {
58916 if(!isWasmInitialized) {
58917 throw new Error("initializeWasm() must be awaited first!");
58919 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
58920 return nativeResponseValue;
58922 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
58924 export function ExpiryTime_from_duration(duration: bigint): bigint {
58925 if(!isWasmInitialized) {
58926 throw new Error("initializeWasm() must be awaited first!");
58928 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
58929 return nativeResponseValue;
58931 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
58933 export function ExpiryTime_as_seconds(this_arg: bigint): bigint {
58934 if(!isWasmInitialized) {
58935 throw new Error("initializeWasm() must be awaited first!");
58937 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
58938 return nativeResponseValue;
58940 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
58942 export function ExpiryTime_as_duration(this_arg: bigint): bigint {
58943 if(!isWasmInitialized) {
58944 throw new Error("initializeWasm() must be awaited first!");
58946 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
58947 return nativeResponseValue;
58949 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
58951 export function PrivateRoute_new(hops: bigint): bigint {
58952 if(!isWasmInitialized) {
58953 throw new Error("initializeWasm() must be awaited first!");
58955 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
58956 return nativeResponseValue;
58958 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
58960 export function PrivateRoute_into_inner(this_arg: bigint): bigint {
58961 if(!isWasmInitialized) {
58962 throw new Error("initializeWasm() must be awaited first!");
58964 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
58965 return nativeResponseValue;
58967 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
58969 export function CreationError_clone(orig: bigint): CreationError {
58970 if(!isWasmInitialized) {
58971 throw new Error("initializeWasm() must be awaited first!");
58973 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
58974 return nativeResponseValue;
58976 // enum LDKCreationError CreationError_description_too_long(void);
58978 export function CreationError_description_too_long(): CreationError {
58979 if(!isWasmInitialized) {
58980 throw new Error("initializeWasm() must be awaited first!");
58982 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
58983 return nativeResponseValue;
58985 // enum LDKCreationError CreationError_route_too_long(void);
58987 export function CreationError_route_too_long(): CreationError {
58988 if(!isWasmInitialized) {
58989 throw new Error("initializeWasm() must be awaited first!");
58991 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
58992 return nativeResponseValue;
58994 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
58996 export function CreationError_timestamp_out_of_bounds(): CreationError {
58997 if(!isWasmInitialized) {
58998 throw new Error("initializeWasm() must be awaited first!");
59000 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
59001 return nativeResponseValue;
59003 // enum LDKCreationError CreationError_invalid_amount(void);
59005 export function CreationError_invalid_amount(): CreationError {
59006 if(!isWasmInitialized) {
59007 throw new Error("initializeWasm() must be awaited first!");
59009 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
59010 return nativeResponseValue;
59012 // enum LDKCreationError CreationError_missing_route_hints(void);
59014 export function CreationError_missing_route_hints(): CreationError {
59015 if(!isWasmInitialized) {
59016 throw new Error("initializeWasm() must be awaited first!");
59018 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
59019 return nativeResponseValue;
59021 // enum LDKCreationError CreationError_min_final_cltv_expiry_delta_too_short(void);
59023 export function CreationError_min_final_cltv_expiry_delta_too_short(): CreationError {
59024 if(!isWasmInitialized) {
59025 throw new Error("initializeWasm() must be awaited first!");
59027 const nativeResponseValue = wasm.TS_CreationError_min_final_cltv_expiry_delta_too_short();
59028 return nativeResponseValue;
59030 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
59032 export function CreationError_eq(a: bigint, b: bigint): boolean {
59033 if(!isWasmInitialized) {
59034 throw new Error("initializeWasm() must be awaited first!");
59036 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
59037 return nativeResponseValue;
59039 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
59041 export function CreationError_to_str(o: bigint): number {
59042 if(!isWasmInitialized) {
59043 throw new Error("initializeWasm() must be awaited first!");
59045 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
59046 return nativeResponseValue;
59048 // enum LDKBolt11SemanticError Bolt11SemanticError_clone(const enum LDKBolt11SemanticError *NONNULL_PTR orig);
59050 export function Bolt11SemanticError_clone(orig: bigint): Bolt11SemanticError {
59051 if(!isWasmInitialized) {
59052 throw new Error("initializeWasm() must be awaited first!");
59054 const nativeResponseValue = wasm.TS_Bolt11SemanticError_clone(orig);
59055 return nativeResponseValue;
59057 // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_hash(void);
59059 export function Bolt11SemanticError_no_payment_hash(): Bolt11SemanticError {
59060 if(!isWasmInitialized) {
59061 throw new Error("initializeWasm() must be awaited first!");
59063 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_hash();
59064 return nativeResponseValue;
59066 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_hashes(void);
59068 export function Bolt11SemanticError_multiple_payment_hashes(): Bolt11SemanticError {
59069 if(!isWasmInitialized) {
59070 throw new Error("initializeWasm() must be awaited first!");
59072 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_hashes();
59073 return nativeResponseValue;
59075 // enum LDKBolt11SemanticError Bolt11SemanticError_no_description(void);
59077 export function Bolt11SemanticError_no_description(): Bolt11SemanticError {
59078 if(!isWasmInitialized) {
59079 throw new Error("initializeWasm() must be awaited first!");
59081 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_description();
59082 return nativeResponseValue;
59084 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_descriptions(void);
59086 export function Bolt11SemanticError_multiple_descriptions(): Bolt11SemanticError {
59087 if(!isWasmInitialized) {
59088 throw new Error("initializeWasm() must be awaited first!");
59090 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_descriptions();
59091 return nativeResponseValue;
59093 // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_secret(void);
59095 export function Bolt11SemanticError_no_payment_secret(): Bolt11SemanticError {
59096 if(!isWasmInitialized) {
59097 throw new Error("initializeWasm() must be awaited first!");
59099 const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_secret();
59100 return nativeResponseValue;
59102 // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_secrets(void);
59104 export function Bolt11SemanticError_multiple_payment_secrets(): Bolt11SemanticError {
59105 if(!isWasmInitialized) {
59106 throw new Error("initializeWasm() must be awaited first!");
59108 const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_secrets();
59109 return nativeResponseValue;
59111 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_features(void);
59113 export function Bolt11SemanticError_invalid_features(): Bolt11SemanticError {
59114 if(!isWasmInitialized) {
59115 throw new Error("initializeWasm() must be awaited first!");
59117 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_features();
59118 return nativeResponseValue;
59120 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_recovery_id(void);
59122 export function Bolt11SemanticError_invalid_recovery_id(): Bolt11SemanticError {
59123 if(!isWasmInitialized) {
59124 throw new Error("initializeWasm() must be awaited first!");
59126 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_recovery_id();
59127 return nativeResponseValue;
59129 // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_signature(void);
59131 export function Bolt11SemanticError_invalid_signature(): Bolt11SemanticError {
59132 if(!isWasmInitialized) {
59133 throw new Error("initializeWasm() must be awaited first!");
59135 const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_signature();
59136 return nativeResponseValue;
59138 // enum LDKBolt11SemanticError Bolt11SemanticError_imprecise_amount(void);
59140 export function Bolt11SemanticError_imprecise_amount(): Bolt11SemanticError {
59141 if(!isWasmInitialized) {
59142 throw new Error("initializeWasm() must be awaited first!");
59144 const nativeResponseValue = wasm.TS_Bolt11SemanticError_imprecise_amount();
59145 return nativeResponseValue;
59147 // bool Bolt11SemanticError_eq(const enum LDKBolt11SemanticError *NONNULL_PTR a, const enum LDKBolt11SemanticError *NONNULL_PTR b);
59149 export function Bolt11SemanticError_eq(a: bigint, b: bigint): boolean {
59150 if(!isWasmInitialized) {
59151 throw new Error("initializeWasm() must be awaited first!");
59153 const nativeResponseValue = wasm.TS_Bolt11SemanticError_eq(a, b);
59154 return nativeResponseValue;
59156 // struct LDKStr Bolt11SemanticError_to_str(const enum LDKBolt11SemanticError *NONNULL_PTR o);
59158 export function Bolt11SemanticError_to_str(o: bigint): number {
59159 if(!isWasmInitialized) {
59160 throw new Error("initializeWasm() must be awaited first!");
59162 const nativeResponseValue = wasm.TS_Bolt11SemanticError_to_str(o);
59163 return nativeResponseValue;
59165 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
59167 export function SignOrCreationError_free(this_ptr: bigint): void {
59168 if(!isWasmInitialized) {
59169 throw new Error("initializeWasm() must be awaited first!");
59171 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
59172 // debug statements here
59174 // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
59176 export function SignOrCreationError_clone_ptr(arg: bigint): bigint {
59177 if(!isWasmInitialized) {
59178 throw new Error("initializeWasm() must be awaited first!");
59180 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
59181 return nativeResponseValue;
59183 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
59185 export function SignOrCreationError_clone(orig: bigint): bigint {
59186 if(!isWasmInitialized) {
59187 throw new Error("initializeWasm() must be awaited first!");
59189 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
59190 return nativeResponseValue;
59192 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
59194 export function SignOrCreationError_sign_error(): bigint {
59195 if(!isWasmInitialized) {
59196 throw new Error("initializeWasm() must be awaited first!");
59198 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
59199 return nativeResponseValue;
59201 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
59203 export function SignOrCreationError_creation_error(a: CreationError): bigint {
59204 if(!isWasmInitialized) {
59205 throw new Error("initializeWasm() must be awaited first!");
59207 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
59208 return nativeResponseValue;
59210 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
59212 export function SignOrCreationError_eq(a: bigint, b: bigint): boolean {
59213 if(!isWasmInitialized) {
59214 throw new Error("initializeWasm() must be awaited first!");
59216 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
59217 return nativeResponseValue;
59219 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
59221 export function SignOrCreationError_to_str(o: bigint): number {
59222 if(!isWasmInitialized) {
59223 throw new Error("initializeWasm() must be awaited first!");
59225 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
59226 return nativeResponseValue;
59228 // struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ payment_parameters_from_zero_amount_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msat);
59230 export function payment_parameters_from_zero_amount_invoice(invoice: bigint, amount_msat: bigint): bigint {
59231 if(!isWasmInitialized) {
59232 throw new Error("initializeWasm() must be awaited first!");
59234 const nativeResponseValue = wasm.TS_payment_parameters_from_zero_amount_invoice(invoice, amount_msat);
59235 return nativeResponseValue;
59237 // struct LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ payment_parameters_from_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice);
59239 export function payment_parameters_from_invoice(invoice: bigint): bigint {
59240 if(!isWasmInitialized) {
59241 throw new Error("initializeWasm() must be awaited first!");
59243 const nativeResponseValue = wasm.TS_payment_parameters_from_invoice(invoice);
59244 return nativeResponseValue;
59246 // 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);
59248 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 {
59249 if(!isWasmInitialized) {
59250 throw new Error("initializeWasm() must be awaited first!");
59252 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);
59253 return nativeResponseValue;
59255 // 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);
59257 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 {
59258 if(!isWasmInitialized) {
59259 throw new Error("initializeWasm() must be awaited first!");
59261 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);
59262 return nativeResponseValue;
59264 // 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);
59266 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 {
59267 if(!isWasmInitialized) {
59268 throw new Error("initializeWasm() must be awaited first!");
59270 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);
59271 return nativeResponseValue;
59273 // 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);
59275 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 {
59276 if(!isWasmInitialized) {
59277 throw new Error("initializeWasm() must be awaited first!");
59279 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);
59280 return nativeResponseValue;
59282 // 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);
59284 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 {
59285 if(!isWasmInitialized) {
59286 throw new Error("initializeWasm() must be awaited first!");
59288 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);
59289 return nativeResponseValue;
59291 // struct LDKCResult_SiPrefixBolt11ParseErrorZ SiPrefix_from_str(struct LDKStr s);
59293 export function SiPrefix_from_str(s: number): bigint {
59294 if(!isWasmInitialized) {
59295 throw new Error("initializeWasm() must be awaited first!");
59297 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
59298 return nativeResponseValue;
59300 // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ Bolt11Invoice_from_str(struct LDKStr s);
59302 export function Bolt11Invoice_from_str(s: number): bigint {
59303 if(!isWasmInitialized) {
59304 throw new Error("initializeWasm() must be awaited first!");
59306 const nativeResponseValue = wasm.TS_Bolt11Invoice_from_str(s);
59307 return nativeResponseValue;
59309 // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ SignedRawBolt11Invoice_from_str(struct LDKStr s);
59311 export function SignedRawBolt11Invoice_from_str(s: number): bigint {
59312 if(!isWasmInitialized) {
59313 throw new Error("initializeWasm() must be awaited first!");
59315 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_from_str(s);
59316 return nativeResponseValue;
59318 // struct LDKStr Bolt11ParseError_to_str(const struct LDKBolt11ParseError *NONNULL_PTR o);
59320 export function Bolt11ParseError_to_str(o: bigint): number {
59321 if(!isWasmInitialized) {
59322 throw new Error("initializeWasm() must be awaited first!");
59324 const nativeResponseValue = wasm.TS_Bolt11ParseError_to_str(o);
59325 return nativeResponseValue;
59327 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
59329 export function ParseOrSemanticError_to_str(o: bigint): number {
59330 if(!isWasmInitialized) {
59331 throw new Error("initializeWasm() must be awaited first!");
59333 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
59334 return nativeResponseValue;
59336 // struct LDKStr Bolt11Invoice_to_str(const struct LDKBolt11Invoice *NONNULL_PTR o);
59338 export function Bolt11Invoice_to_str(o: bigint): number {
59339 if(!isWasmInitialized) {
59340 throw new Error("initializeWasm() must be awaited first!");
59342 const nativeResponseValue = wasm.TS_Bolt11Invoice_to_str(o);
59343 return nativeResponseValue;
59345 // struct LDKStr SignedRawBolt11Invoice_to_str(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
59347 export function SignedRawBolt11Invoice_to_str(o: bigint): number {
59348 if(!isWasmInitialized) {
59349 throw new Error("initializeWasm() must be awaited first!");
59351 const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_to_str(o);
59352 return nativeResponseValue;
59354 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
59356 export function Currency_to_str(o: bigint): number {
59357 if(!isWasmInitialized) {
59358 throw new Error("initializeWasm() must be awaited first!");
59360 const nativeResponseValue = wasm.TS_Currency_to_str(o);
59361 return nativeResponseValue;
59363 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
59365 export function SiPrefix_to_str(o: bigint): number {
59366 if(!isWasmInitialized) {
59367 throw new Error("initializeWasm() must be awaited first!");
59369 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
59370 return nativeResponseValue;
59374 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) {
59375 const weak: WeakRef<object>|undefined = js_objs[obj_ptr];
59376 if (weak == null || weak == undefined) {
59377 console.error("Got function call on unknown/free'd JS object!");
59378 throw new Error("Got function call on unknown/free'd JS object!");
59380 const obj = weak.deref();
59381 if (obj == null || obj == undefined) {
59382 console.error("Got function call on GC'd JS object!");
59383 throw new Error("Got function call on GC'd JS object!");
59387 case 0: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
59388 case 1: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
59389 case 2: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
59390 case 3: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
59391 case 4: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
59392 case 5: fn = Object.getOwnPropertyDescriptor(obj, "provide_channel_parameters"); break;
59393 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
59394 case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment"); break;
59395 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
59396 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
59397 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_htlc_transaction"); break;
59398 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
59399 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
59400 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_anchor_input"); break;
59401 case 14: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement_with_funding_key"); break;
59402 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
59403 case 16: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
59404 case 17: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
59405 case 18: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
59406 case 19: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
59407 case 20: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
59408 case 21: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transactions"); break;
59409 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
59410 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
59411 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_node_id"); break;
59412 case 25: fn = Object.getOwnPropertyDescriptor(obj, "ecdh"); break;
59413 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
59414 case 27: fn = Object.getOwnPropertyDescriptor(obj, "sign_bolt12_invoice_request"); break;
59415 case 28: fn = Object.getOwnPropertyDescriptor(obj, "sign_bolt12_invoice"); break;
59416 case 29: fn = Object.getOwnPropertyDescriptor(obj, "sign_gossip_message"); break;
59417 case 30: fn = Object.getOwnPropertyDescriptor(obj, "generate_channel_keys_id"); break;
59418 case 31: fn = Object.getOwnPropertyDescriptor(obj, "derive_channel_signer"); break;
59419 case 32: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
59420 case 33: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
59421 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
59422 case 35: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
59423 case 36: fn = Object.getOwnPropertyDescriptor(obj, "find_path"); break;
59424 case 37: fn = Object.getOwnPropertyDescriptor(obj, "create_blinded_paths"); break;
59425 case 38: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
59426 case 39: fn = Object.getOwnPropertyDescriptor(obj, "find_route_with_id"); break;
59427 case 40: fn = Object.getOwnPropertyDescriptor(obj, "create_blinded_payment_paths"); break;
59428 case 41: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
59429 case 42: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
59430 case 43: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
59431 case 44: fn = Object.getOwnPropertyDescriptor(obj, "tlv_type"); break;
59432 case 45: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
59433 case 46: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
59434 case 47: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
59435 case 48: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
59436 case 49: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
59437 case 50: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
59438 case 51: fn = Object.getOwnPropertyDescriptor(obj, "remove"); break;
59439 case 52: fn = Object.getOwnPropertyDescriptor(obj, "list"); break;
59440 case 53: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
59441 case 54: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
59442 case 55: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
59443 case 56: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
59444 case 57: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
59445 case 58: fn = Object.getOwnPropertyDescriptor(obj, "time_passed"); break;
59446 case 59: fn = Object.getOwnPropertyDescriptor(obj, "read_lock"); break;
59447 case 60: fn = Object.getOwnPropertyDescriptor(obj, "write_lock"); break;
59448 case 61: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
59449 case 62: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
59450 case 63: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
59451 case 64: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
59452 case 65: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
59453 case 66: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
59454 case 67: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
59455 case 68: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
59456 case 69: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
59457 case 70: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
59458 case 71: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
59459 case 72: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
59460 case 73: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
59461 case 74: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
59462 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
59463 case 76: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
59464 case 77: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
59465 case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
59466 case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel_v2"); break;
59467 case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
59468 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel_v2"); break;
59469 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
59470 case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
59471 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
59472 case 85: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
59473 case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
59474 case 87: fn = Object.getOwnPropertyDescriptor(obj, "handle_stfu"); break;
59475 case 88: fn = Object.getOwnPropertyDescriptor(obj, "handle_splice"); break;
59476 case 89: fn = Object.getOwnPropertyDescriptor(obj, "handle_splice_ack"); break;
59477 case 90: fn = Object.getOwnPropertyDescriptor(obj, "handle_splice_locked"); break;
59478 case 91: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_input"); break;
59479 case 92: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_output"); break;
59480 case 93: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_input"); break;
59481 case 94: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_output"); break;
59482 case 95: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_complete"); break;
59483 case 96: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_signatures"); break;
59484 case 97: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_init_rbf"); break;
59485 case 98: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_ack_rbf"); break;
59486 case 99: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_abort"); break;
59487 case 100: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
59488 case 101: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
59489 case 102: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
59490 case 103: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
59491 case 104: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
59492 case 105: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
59493 case 106: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
59494 case 107: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
59495 case 108: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
59496 case 109: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
59497 case 110: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
59498 case 111: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
59499 case 112: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
59500 case 113: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
59501 case 114: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
59502 case 115: fn = Object.getOwnPropertyDescriptor(obj, "get_chain_hashes"); break;
59503 case 116: fn = Object.getOwnPropertyDescriptor(obj, "handle_message"); break;
59504 case 117: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_messages"); break;
59505 case 118: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
59506 case 119: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
59507 case 120: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
59508 case 121: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
59509 case 122: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
59510 case 123: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
59511 case 124: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
59512 case 125: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
59513 case 126: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
59514 case 127: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
59515 case 128: fn = Object.getOwnPropertyDescriptor(obj, "processing_queue_high"); break;
59516 case 129: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
59517 case 130: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
59518 case 131: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_connections_needed"); break;
59519 case 132: fn = Object.getOwnPropertyDescriptor(obj, "handle_onion_message"); break;
59520 case 133: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
59521 case 134: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
59522 case 135: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
59523 case 136: fn = Object.getOwnPropertyDescriptor(obj, "timer_tick_occurred"); break;
59524 case 137: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
59525 case 138: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
59526 case 139: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
59527 case 140: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
59528 case 141: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
59529 case 142: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
59530 case 143: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
59531 case 144: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
59532 case 145: fn = Object.getOwnPropertyDescriptor(obj, "read_custom_message"); break;
59533 case 146: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_custom_messages"); break;
59534 case 147: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
59535 case 148: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
59536 case 149: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
59537 case 150: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
59538 case 151: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
59539 case 152: fn = Object.getOwnPropertyDescriptor(obj, "select_confirmed_utxos"); break;
59540 case 153: fn = Object.getOwnPropertyDescriptor(obj, "sign_psbt"); break;
59541 case 154: fn = Object.getOwnPropertyDescriptor(obj, "list_confirmed_utxos"); break;
59542 case 155: fn = Object.getOwnPropertyDescriptor(obj, "get_change_script"); break;
59543 case 156: fn = Object.getOwnPropertyDescriptor(obj, "sign_psbt"); break;
59545 console.error("Got unknown function call with id " + fn_id + " from C!");
59546 throw new Error("Got unknown function call with id " + fn_id + " from C!");
59548 if (fn == null || fn == undefined) {
59549 console.error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
59550 throw new Error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
59554 ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
59556 console.error("Got an exception calling function with id " + fn_id + "! This is fatal.");
59560 if (ret === undefined || ret === null) return BigInt(0);
59561 return BigInt(ret);