*/
public static native long LDKCVec_u8Z_new(number[] elems);
+ // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
+ export function TxOut_get_script_pubkey(thing: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TxOut_get_script_pubkey(thing);
+ return decodeArray(nativeResponseValue);
+ }
+ // uint64_t TxOut_get_value (struct LDKTxOut* thing)
+ export function TxOut_get_value(thing: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TxOut_get_value(thing);
+ return nativeResponseValue;
+ }
public static native boolean LDKCResult_SecretKeyErrorZ_result_ok(long arg);
public static native Uint8Array LDKCResult_SecretKeyErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_SecretKeyErrorZ_get_err(long arg);
public static native boolean LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_TrustedClosingTransactionNoneZ_result_ok(long arg);
+ public static native number LDKCResult_TrustedClosingTransactionNoneZ_get_ok(long arg);
+ public static native void LDKCResult_TrustedClosingTransactionNoneZ_get_err(long arg);
public static native boolean LDKCResult_CommitmentTransactionDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_CommitmentTransactionDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_CommitmentTransactionDecodeErrorZ_get_err(long arg);
public static native boolean LDKCResult_CVec_SignatureZNoneZ_result_ok(long arg);
public static native Uint8Array[] LDKCResult_CVec_SignatureZNoneZ_get_ok(long arg);
public static native void LDKCResult_CVec_SignatureZNoneZ_get_err(long arg);
+ public static native boolean LDKCResult_ShutdownScriptDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ShutdownScriptDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ShutdownScriptDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ShutdownScriptInvalidShutdownScriptZ_result_ok(long arg);
+ public static native number LDKCResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(long arg);
+ public static native number LDKCResult_ShutdownScriptInvalidShutdownScriptZ_get_err(long arg);
public static native boolean LDKCResult_NoneErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneErrorZ_get_ok(long arg);
public static native IOError LDKCResult_NoneErrorZ_get_err(long arg);
public static native number LDKCResult_TxOutAccessErrorZ_get_ok(long arg);
public static native AccessError LDKCResult_TxOutAccessErrorZ_get_err(long arg);
public static native long LDKC2Tuple_usizeTransactionZ_new(number a, Uint8Array b);
- public static native number LDKC2Tuple_usizeTransactionZ_get_a(long ptr);
- public static native Uint8Array LDKC2Tuple_usizeTransactionZ_get_b(long ptr);
+ // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR tuple);
+ export function C2Tuple_usizeTransactionZ_get_a(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_usizeTransactionZ_get_a(tuple);
+ return nativeResponseValue;
+ }
+ // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR tuple);
+ export function C2Tuple_usizeTransactionZ_get_b(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_usizeTransactionZ_get_b(tuple);
+ return decodeArray(nativeResponseValue);
+ }
public static native long LDKCVec_C2Tuple_usizeTransactionZZ_new(number[] elems);
public static native boolean LDKCResult_NoneChannelMonitorUpdateErrZ_result_ok(long arg);
public static native void LDKCResult_NoneChannelMonitorUpdateErrZ_get_ok(long arg);
public number htlc_event;
HTLCEvent(number htlc_event) { this.htlc_event = htlc_event; }
}
- export class CommitmentTxBroadcasted extends LDKMonitorEvent {
- public number commitment_tx_broadcasted;
- CommitmentTxBroadcasted(number commitment_tx_broadcasted) { this.commitment_tx_broadcasted = commitment_tx_broadcasted; }
+ export class CommitmentTxConfirmed extends LDKMonitorEvent {
+ public number commitment_tx_confirmed;
+ CommitmentTxConfirmed(number commitment_tx_confirmed) { this.commitment_tx_confirmed = commitment_tx_confirmed; }
}
static native void init();
}
}
static { LDKCOption_C2Tuple_usizeTransactionZZ.init(); }
public static native LDKCOption_C2Tuple_usizeTransactionZZ LDKCOption_C2Tuple_usizeTransactionZZ_ref_from_ptr(long ptr);
+ public static class LDKNetworkUpdate {
+ private LDKNetworkUpdate() {}
+ export class ChannelUpdateMessage extends LDKNetworkUpdate {
+ public number msg;
+ ChannelUpdateMessage(number msg) { this.msg = msg; }
+ }
+ export class ChannelClosed extends LDKNetworkUpdate {
+ public number short_channel_id;
+ public boolean is_permanent;
+ ChannelClosed(number short_channel_id, boolean is_permanent) { this.short_channel_id = short_channel_id; this.is_permanent = is_permanent; }
+ }
+ export class NodeFailure extends LDKNetworkUpdate {
+ public Uint8Array node_id;
+ public boolean is_permanent;
+ NodeFailure(Uint8Array node_id, boolean is_permanent) { this.node_id = node_id; this.is_permanent = is_permanent; }
+ }
+ static native void init();
+ }
+ static { LDKNetworkUpdate.init(); }
+ public static native LDKNetworkUpdate LDKNetworkUpdate_ref_from_ptr(long ptr);
+ public static class LDKCOption_NetworkUpdateZ {
+ private LDKCOption_NetworkUpdateZ() {}
+ export class Some extends LDKCOption_NetworkUpdateZ {
+ public number some;
+ Some(number some) { this.some = some; }
+ }
+ export class None extends LDKCOption_NetworkUpdateZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_NetworkUpdateZ.init(); }
+ public static native LDKCOption_NetworkUpdateZ LDKCOption_NetworkUpdateZ_ref_from_ptr(long ptr);
public static class LDKSpendableOutputDescriptor {
private LDKSpendableOutputDescriptor() {}
export class StaticOutput extends LDKSpendableOutputDescriptor {
export class IgnoreError extends LDKErrorAction {
IgnoreError() { }
}
+ export class IgnoreAndLog extends LDKErrorAction {
+ public Level ignore_and_log;
+ IgnoreAndLog(Level ignore_and_log) { this.ignore_and_log = ignore_and_log; }
+ }
export class SendErrorMessage extends LDKErrorAction {
public number msg;
SendErrorMessage(number msg) { this.msg = msg; }
}
static { LDKErrorAction.init(); }
public static native LDKErrorAction LDKErrorAction_ref_from_ptr(long ptr);
- public static class LDKHTLCFailChannelUpdate {
- private LDKHTLCFailChannelUpdate() {}
- export class ChannelUpdateMessage extends LDKHTLCFailChannelUpdate {
- public number msg;
- ChannelUpdateMessage(number msg) { this.msg = msg; }
- }
- export class ChannelClosed extends LDKHTLCFailChannelUpdate {
- public number short_channel_id;
- public boolean is_permanent;
- ChannelClosed(number short_channel_id, boolean is_permanent) { this.short_channel_id = short_channel_id; this.is_permanent = is_permanent; }
- }
- export class NodeFailure extends LDKHTLCFailChannelUpdate {
- public Uint8Array node_id;
- public boolean is_permanent;
- NodeFailure(Uint8Array node_id, boolean is_permanent) { this.node_id = node_id; this.is_permanent = is_permanent; }
- }
- static native void init();
- }
- static { LDKHTLCFailChannelUpdate.init(); }
- public static native LDKHTLCFailChannelUpdate LDKHTLCFailChannelUpdate_ref_from_ptr(long ptr);
public static class LDKMessageSendEvent {
private LDKMessageSendEvent() {}
export class SendAcceptChannel extends LDKMessageSendEvent {
public number msg;
BroadcastChannelUpdate(number msg) { this.msg = msg; }
}
+ export class SendChannelUpdate extends LDKMessageSendEvent {
+ public Uint8Array node_id;
+ public number msg;
+ SendChannelUpdate(Uint8Array node_id, number msg) { this.node_id = node_id; this.msg = msg; }
+ }
export class HandleError extends LDKMessageSendEvent {
public Uint8Array node_id;
public number action;
HandleError(Uint8Array node_id, number action) { this.node_id = node_id; this.action = action; }
}
- export class PaymentFailureNetworkUpdate extends LDKMessageSendEvent {
- public number update;
- PaymentFailureNetworkUpdate(number update) { this.update = update; }
- }
export class SendChannelRangeQuery extends LDKMessageSendEvent {
public Uint8Array node_id;
public number msg;
public static native boolean LDKCResult_SpendableOutputDescriptorDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_NoneNoneZ_result_ok(long arg);
+ public static native void LDKCResult_NoneNoneZ_get_ok(long arg);
+ public static native void LDKCResult_NoneNoneZ_get_err(long arg);
public static native long LDKC2Tuple_SignatureCVec_SignatureZZ_new(Uint8Array a, Uint8Array[] b);
- public static native Uint8Array LDKC2Tuple_SignatureCVec_SignatureZZ_get_a(long ptr);
- public static native Uint8Array[] LDKC2Tuple_SignatureCVec_SignatureZZ_get_b(long ptr);
+ // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR tuple);
+ export function C2Tuple_SignatureCVec_SignatureZZ_get_a(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_SignatureCVec_SignatureZZ_get_a(tuple);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR tuple);
+ export function C2Tuple_SignatureCVec_SignatureZZ_get_b(tuple: number): Uint8Array[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_SignatureCVec_SignatureZZ_get_b(tuple);
+ return nativeResponseValue;
+ }
public static native boolean LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok(long arg);
public static native number LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(long arg);
public static native void LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(long arg);
export interface LDKBaseSign {
get_per_commitment_point (idx: number): Uint8Array;
release_commitment_secret (idx: number): Uint8Array;
+ validate_holder_commitment (holder_tx: number): number;
channel_keys_id (): Uint8Array;
sign_counterparty_commitment (commitment_tx: number): number;
+ validate_counterparty_revocation (idx: number, secret: Uint8Array): number;
sign_holder_commitment_and_htlcs (commitment_tx: number): number;
sign_justice_revoked_output (justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array): number;
sign_justice_revoked_htlc (justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: number): number;
sign_counterparty_htlc_transaction (htlc_tx: Uint8Array, input: number, amount: number, per_commitment_point: Uint8Array, htlc: number): number;
- sign_closing_transaction (closing_tx: Uint8Array): number;
+ sign_closing_transaction (closing_tx: number): number;
sign_channel_announcement (msg: number): number;
ready_channel (channel_parameters: number): void;
}
const nativeResponseValue = wasm.BaseSign_release_commitment_secret(this_arg, idx);
return decodeArray(nativeResponseValue);
}
+ // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx
+ export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_validate_holder_commitment(this_arg, holder_tx);
+ return nativeResponseValue;
+ }
// LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
export function BaseSign_channel_keys_id(this_arg: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.BaseSign_sign_counterparty_commitment(this_arg, commitment_tx);
return nativeResponseValue;
}
+ // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
+ export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: number, secret: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_validate_counterparty_revocation(this_arg, idx, encodeArray(secret));
+ return nativeResponseValue;
+ }
// LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.BaseSign_sign_counterparty_htlc_transaction(this_arg, encodeArray(htlc_tx), input, amount, encodeArray(per_commitment_point), htlc);
return nativeResponseValue;
}
- // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction closing_tx
- export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: Uint8Array): number {
+ // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
+ export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.BaseSign_sign_closing_transaction(this_arg, encodeArray(closing_tx));
+ const nativeResponseValue = wasm.BaseSign_sign_closing_transaction(this_arg, closing_tx);
return nativeResponseValue;
}
// LDKCResult_SignatureNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
public static native Uint8Array LDKCResult_TransactionNoneZ_get_ok(long arg);
public static native void LDKCResult_TransactionNoneZ_get_err(long arg);
public static native long LDKC2Tuple_BlockHashChannelMonitorZ_new(Uint8Array a, number b);
- public static native Uint8Array LDKC2Tuple_BlockHashChannelMonitorZ_get_a(long ptr);
- public static native number LDKC2Tuple_BlockHashChannelMonitorZ_get_b(long ptr);
+ // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR tuple);
+ export function C2Tuple_BlockHashChannelMonitorZ_get_a(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_get_a(tuple);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR tuple);
+ export function C2Tuple_BlockHashChannelMonitorZ_get_b(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_get_b(tuple);
+ return nativeResponseValue;
+ }
public static native long LDKCVec_C2Tuple_BlockHashChannelMonitorZZ_new(number[] elems);
public static native boolean LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_result_ok(long arg);
public static native number[] LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_ok(long arg);
public static native IOError LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_err(long arg);
+ public static class LDKCOption_u16Z {
+ private LDKCOption_u16Z() {}
+ export class Some extends LDKCOption_u16Z {
+ public number some;
+ Some(number some) { this.some = some; }
+ }
+ export class None extends LDKCOption_u16Z {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_u16Z.init(); }
+ public static native LDKCOption_u16Z LDKCOption_u16Z_ref_from_ptr(long ptr);
public static class LDKAPIError {
private LDKAPIError() {}
export class APIMisuseError extends LDKAPIError {
export class MonitorUpdateFailed extends LDKAPIError {
MonitorUpdateFailed() { }
}
+ export class IncompatibleShutdownScript extends LDKAPIError {
+ public number script;
+ IncompatibleShutdownScript(number script) { this.script = script; }
+ }
static native void init();
}
static { LDKAPIError.init(); }
public static native boolean LDKCResult_NonePaymentSendFailureZ_result_ok(long arg);
public static native void LDKCResult_NonePaymentSendFailureZ_get_ok(long arg);
public static native number LDKCResult_NonePaymentSendFailureZ_get_err(long arg);
+ public static native boolean LDKCResult_PaymentHashPaymentSendFailureZ_result_ok(long arg);
+ public static native Uint8Array LDKCResult_PaymentHashPaymentSendFailureZ_get_ok(long arg);
+ public static native number LDKCResult_PaymentHashPaymentSendFailureZ_get_err(long arg);
public static class LDKNetAddress {
private LDKNetAddress() {}
export class IPv4 extends LDKNetAddress {
public static native LDKNetAddress LDKNetAddress_ref_from_ptr(long ptr);
public static native long LDKCVec_NetAddressZ_new(number[] elems);
public static native long LDKC2Tuple_PaymentHashPaymentSecretZ_new(Uint8Array a, Uint8Array b);
- public static native Uint8Array LDKC2Tuple_PaymentHashPaymentSecretZ_get_a(long ptr);
- public static native Uint8Array LDKC2Tuple_PaymentHashPaymentSecretZ_get_b(long ptr);
+ // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR tuple);
+ export function C2Tuple_PaymentHashPaymentSecretZ_get_a(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_PaymentHashPaymentSecretZ_get_a(tuple);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR tuple);
+ export function C2Tuple_PaymentHashPaymentSecretZ_get_b(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_PaymentHashPaymentSecretZ_get_b(tuple);
+ return decodeArray(nativeResponseValue);
+ }
public static native boolean LDKCResult_PaymentSecretAPIErrorZ_result_ok(long arg);
public static native Uint8Array LDKCResult_PaymentSecretAPIErrorZ_get_ok(long arg);
public static native number LDKCResult_PaymentSecretAPIErrorZ_get_err(long arg);
export interface LDKKeysInterface {
get_node_secret (): Uint8Array;
get_destination_script (): Uint8Array;
- get_shutdown_pubkey (): Uint8Array;
+ get_shutdown_scriptpubkey (): number;
get_channel_signer (inbound: boolean, channel_value_satoshis: number): number;
get_secure_random_bytes (): Uint8Array;
read_chan_signer (reader: Uint8Array): number;
const nativeResponseValue = wasm.KeysInterface_get_destination_script(this_arg);
return decodeArray(nativeResponseValue);
}
- // LDKPublicKey KeysInterface_get_shutdown_pubkey LDKKeysInterface *NONNULL_PTR this_arg
- export function KeysInterface_get_shutdown_pubkey(this_arg: number): Uint8Array {
+ // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
+ export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.KeysInterface_get_shutdown_pubkey(this_arg);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.KeysInterface_get_shutdown_scriptpubkey(this_arg);
+ return nativeResponseValue;
}
// LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: number): number {
public static native long LDKC2Tuple_BlockHashChannelManagerZ_new(Uint8Array a, number b);
- public static native Uint8Array LDKC2Tuple_BlockHashChannelManagerZ_get_a(long ptr);
- public static native number LDKC2Tuple_BlockHashChannelManagerZ_get_b(long ptr);
+ // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR tuple);
+ export function C2Tuple_BlockHashChannelManagerZ_get_a(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelManagerZ_get_a(tuple);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR tuple);
+ export function C2Tuple_BlockHashChannelManagerZ_get_b(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelManagerZ_get_b(tuple);
+ return nativeResponseValue;
+ }
public static native boolean LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(long arg);
public static native boolean LDKCResult_OutPointDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_OutPointDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_OutPointDecodeErrorZ_get_err(long arg);
+
+
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
+
+ export interface LDKType {
+ type_id (): number;
+ debug_str (): String;
+ write (): Uint8Array;
+ }
+
+ export function LDKType_new(impl: LDKType): number {
+ throw new Error('unimplemented'); // TODO: bind to WASM
+ }
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
+
+
+ // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
+ export function Type_type_id(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Type_type_id(this_arg);
+ return nativeResponseValue;
+ }
+ // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
+ export function Type_debug_str(this_arg: number): String {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Type_debug_str(this_arg);
+ return nativeResponseValue;
+ }
+ // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
+ export function Type_write(this_arg: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Type_write(this_arg);
+ return decodeArray(nativeResponseValue);
+ }
+ public static class LDKCOption_TypeZ {
+ private LDKCOption_TypeZ() {}
+ export class Some extends LDKCOption_TypeZ {
+ public number some;
+ Some(number some) { this.some = some; }
+ }
+ export class None extends LDKCOption_TypeZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_TypeZ.init(); }
+ public static native LDKCOption_TypeZ LDKCOption_TypeZ_ref_from_ptr(long ptr);
+ public static native boolean LDKCResult_COption_TypeZDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_COption_TypeZDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_COption_TypeZDecodeErrorZ_get_err(long arg);
public static native boolean LDKCResult_SiPrefixNoneZ_result_ok(long arg);
public static native SiPrefix LDKCResult_SiPrefixNoneZ_get_ok(long arg);
public static native void LDKCResult_SiPrefixNoneZ_get_err(long arg);
public static native number LDKCResult_SignedRawInvoiceNoneZ_get_ok(long arg);
public static native void LDKCResult_SignedRawInvoiceNoneZ_get_err(long arg);
public static native long LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ_new(number a, Uint8Array b, number c);
- public static native number LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(long ptr);
- public static native Uint8Array LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(long ptr);
- public static native number LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(long ptr);
+ // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR tuple);
+ export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(tuple);
+ return nativeResponseValue;
+ }
+ // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR tuple);
+ export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(tuple);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR tuple);
+ export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(tuple);
+ return nativeResponseValue;
+ }
public static native boolean LDKCResult_PayeePubKeyErrorZ_result_ok(long arg);
public static native number LDKCResult_PayeePubKeyErrorZ_get_ok(long arg);
public static native Secp256k1Error LDKCResult_PayeePubKeyErrorZ_get_err(long arg);
public static native void LDKCResult_NoneMonitorUpdateErrorZ_get_ok(long arg);
public static native number LDKCResult_NoneMonitorUpdateErrorZ_get_err(long arg);
public static native long LDKC2Tuple_OutPointScriptZ_new(number a, Uint8Array b);
- public static native number LDKC2Tuple_OutPointScriptZ_get_a(long ptr);
- public static native Uint8Array LDKC2Tuple_OutPointScriptZ_get_b(long ptr);
+ // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR tuple);
+ export function C2Tuple_OutPointScriptZ_get_a(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_OutPointScriptZ_get_a(tuple);
+ return nativeResponseValue;
+ }
+ // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR tuple);
+ export function C2Tuple_OutPointScriptZ_get_b(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_OutPointScriptZ_get_b(tuple);
+ return decodeArray(nativeResponseValue);
+ }
public static native long LDKC2Tuple_u32ScriptZ_new(number a, Uint8Array b);
- public static native number LDKC2Tuple_u32ScriptZ_get_a(long ptr);
- public static native Uint8Array LDKC2Tuple_u32ScriptZ_get_b(long ptr);
+ // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR tuple);
+ export function C2Tuple_u32ScriptZ_get_a(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_u32ScriptZ_get_a(tuple);
+ return nativeResponseValue;
+ }
+ // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR tuple);
+ export function C2Tuple_u32ScriptZ_get_b(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_u32ScriptZ_get_b(tuple);
+ return decodeArray(nativeResponseValue);
+ }
public static native long LDKCVec_C2Tuple_u32ScriptZZ_new(number[] elems);
public static native long LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(Uint8Array a, number[] b);
- public static native Uint8Array LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(long ptr);
- public static native number[] LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(long ptr);
+ // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR tuple);
+ export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(tuple);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR tuple);
+ export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(tuple: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(tuple);
+ return nativeResponseValue;
+ }
public static native long LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_new(number[] elems);
+ public static class LDKPaymentPurpose {
+ private LDKPaymentPurpose() {}
+ export class InvoicePayment extends LDKPaymentPurpose {
+ public Uint8Array payment_preimage;
+ public Uint8Array payment_secret;
+ public number user_payment_id;
+ InvoicePayment(Uint8Array payment_preimage, Uint8Array payment_secret, number user_payment_id) { this.payment_preimage = payment_preimage; this.payment_secret = payment_secret; this.user_payment_id = user_payment_id; }
+ }
+ export class SpontaneousPayment extends LDKPaymentPurpose {
+ public Uint8Array spontaneous_payment;
+ SpontaneousPayment(Uint8Array spontaneous_payment) { this.spontaneous_payment = spontaneous_payment; }
+ }
+ static native void init();
+ }
+ static { LDKPaymentPurpose.init(); }
+ public static native LDKPaymentPurpose LDKPaymentPurpose_ref_from_ptr(long ptr);
+ public static class LDKClosureReason {
+ private LDKClosureReason() {}
+ export class CounterpartyForceClosed extends LDKClosureReason {
+ public String peer_msg;
+ CounterpartyForceClosed(String peer_msg) { this.peer_msg = peer_msg; }
+ }
+ export class HolderForceClosed extends LDKClosureReason {
+ HolderForceClosed() { }
+ }
+ export class CooperativeClosure extends LDKClosureReason {
+ CooperativeClosure() { }
+ }
+ export class CommitmentTxConfirmed extends LDKClosureReason {
+ CommitmentTxConfirmed() { }
+ }
+ export class ProcessingError extends LDKClosureReason {
+ public String err;
+ ProcessingError(String err) { this.err = err; }
+ }
+ export class DisconnectedPeer extends LDKClosureReason {
+ DisconnectedPeer() { }
+ }
+ export class OutdatedChannelManager extends LDKClosureReason {
+ OutdatedChannelManager() { }
+ }
+ static native void init();
+ }
+ static { LDKClosureReason.init(); }
+ public static native LDKClosureReason LDKClosureReason_ref_from_ptr(long ptr);
public static class LDKEvent {
private LDKEvent() {}
export class FundingGenerationReady extends LDKEvent {
}
export class PaymentReceived extends LDKEvent {
public Uint8Array payment_hash;
- public Uint8Array payment_preimage;
- public Uint8Array payment_secret;
public number amt;
- public number user_payment_id;
- PaymentReceived(Uint8Array payment_hash, Uint8Array payment_preimage, Uint8Array payment_secret, number amt, number user_payment_id) { this.payment_hash = payment_hash; this.payment_preimage = payment_preimage; this.payment_secret = payment_secret; this.amt = amt; this.user_payment_id = user_payment_id; }
+ public number purpose;
+ PaymentReceived(Uint8Array payment_hash, number amt, number purpose) { this.payment_hash = payment_hash; this.amt = amt; this.purpose = purpose; }
}
export class PaymentSent extends LDKEvent {
public Uint8Array payment_preimage;
PaymentSent(Uint8Array payment_preimage) { this.payment_preimage = payment_preimage; }
}
- export class PaymentFailed extends LDKEvent {
+ export class PaymentPathFailed extends LDKEvent {
public Uint8Array payment_hash;
public boolean rejected_by_dest;
- PaymentFailed(Uint8Array payment_hash, boolean rejected_by_dest) { this.payment_hash = payment_hash; this.rejected_by_dest = rejected_by_dest; }
+ public number network_update;
+ public boolean all_paths_failed;
+ public number[] path;
+ PaymentPathFailed(Uint8Array payment_hash, boolean rejected_by_dest, number network_update, boolean all_paths_failed, number[] path) { this.payment_hash = payment_hash; this.rejected_by_dest = rejected_by_dest; this.network_update = network_update; this.all_paths_failed = all_paths_failed; this.path = path; }
}
export class PendingHTLCsForwardable extends LDKEvent {
public number time_forwardable;
public number[] outputs;
SpendableOutputs(number[] outputs) { this.outputs = outputs; }
}
+ export class PaymentForwarded extends LDKEvent {
+ public number fee_earned_msat;
+ public boolean claim_from_onchain_tx;
+ PaymentForwarded(number fee_earned_msat, boolean claim_from_onchain_tx) { this.fee_earned_msat = fee_earned_msat; this.claim_from_onchain_tx = claim_from_onchain_tx; }
+ }
+ export class ChannelClosed extends LDKEvent {
+ public Uint8Array channel_id;
+ public number reason;
+ ChannelClosed(Uint8Array channel_id, number reason) { this.channel_id = channel_id; this.reason = reason; }
+ }
static native void init();
}
static { LDKEvent.init(); }
public static native LDKEvent LDKEvent_ref_from_ptr(long ptr);
public static native long LDKCVec_EventZ_new(number[] elems);
public static native long LDKC2Tuple_u32TxOutZ_new(number a, number b);
- public static native number LDKC2Tuple_u32TxOutZ_get_a(long ptr);
- public static native number LDKC2Tuple_u32TxOutZ_get_b(long ptr);
+ // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR tuple);
+ export function C2Tuple_u32TxOutZ_get_a(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_u32TxOutZ_get_a(tuple);
+ return nativeResponseValue;
+ }
+ // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR tuple);
+ export function C2Tuple_u32TxOutZ_get_b(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_u32TxOutZ_get_b(tuple);
+ return nativeResponseValue;
+ }
public static native long LDKCVec_C2Tuple_u32TxOutZZ_new(number[] elems);
public static native long LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(Uint8Array a, number[] b);
- public static native Uint8Array LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(long ptr);
- public static native number[] LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(long ptr);
+ // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR tuple);
+ export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(tuple);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR tuple);
+ export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(tuple: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(tuple);
+ return nativeResponseValue;
+ }
public static native long LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_new(number[] elems);
+ public static class LDKBalance {
+ private LDKBalance() {}
+ export class ClaimableOnChannelClose extends LDKBalance {
+ public number claimable_amount_satoshis;
+ ClaimableOnChannelClose(number claimable_amount_satoshis) { this.claimable_amount_satoshis = claimable_amount_satoshis; }
+ }
+ export class ClaimableAwaitingConfirmations extends LDKBalance {
+ public number claimable_amount_satoshis;
+ public number confirmation_height;
+ ClaimableAwaitingConfirmations(number claimable_amount_satoshis, number confirmation_height) { this.claimable_amount_satoshis = claimable_amount_satoshis; this.confirmation_height = confirmation_height; }
+ }
+ export class ContentiousClaimable extends LDKBalance {
+ public number claimable_amount_satoshis;
+ public number timeout_height;
+ ContentiousClaimable(number claimable_amount_satoshis, number timeout_height) { this.claimable_amount_satoshis = claimable_amount_satoshis; this.timeout_height = timeout_height; }
+ }
+ export class MaybeClaimableHTLCAwaitingTimeout extends LDKBalance {
+ public number claimable_amount_satoshis;
+ public number claimable_height;
+ MaybeClaimableHTLCAwaitingTimeout(number claimable_amount_satoshis, number claimable_height) { this.claimable_amount_satoshis = claimable_amount_satoshis; this.claimable_height = claimable_height; }
+ }
+ static native void init();
+ }
+ static { LDKBalance.init(); }
+ public static native LDKBalance LDKBalance_ref_from_ptr(long ptr);
+ public static native long LDKCVec_BalanceZ_new(number[] elems);
public static native boolean LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_boolLightningErrorZ_result_ok(long arg);
- public static native boolean LDKCResult_boolLightningErrorZ_get_ok(long arg);
- public static native number LDKCResult_boolLightningErrorZ_get_err(long arg);
- public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(number a, number b, number c);
- public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(long ptr);
- public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(long ptr);
- public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(long ptr);
- public static native long LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(number[] elems);
- public static native long LDKCVec_NodeAnnouncementZ_new(number[] elems);
public static native boolean LDKCResult_NoneLightningErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneLightningErrorZ_get_ok(long arg);
public static native number LDKCResult_NoneLightningErrorZ_get_err(long arg);
- public static native boolean LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(long arg);
- public static native Uint8Array LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(long arg);
- public static native number LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NonePeerHandleErrorZ_result_ok(long arg);
- public static native void LDKCResult_NonePeerHandleErrorZ_get_ok(long arg);
- public static native number LDKCResult_NonePeerHandleErrorZ_get_err(long arg);
+ public static native long LDKC2Tuple_PublicKeyTypeZ_new(Uint8Array a, number b);
+ // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR tuple);
+ export function C2Tuple_PublicKeyTypeZ_get_a(tuple: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_PublicKeyTypeZ_get_a(tuple);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR tuple);
+ export function C2Tuple_PublicKeyTypeZ_get_b(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_PublicKeyTypeZ_get_b(tuple);
+ return nativeResponseValue;
+ }
+ public static native long LDKCVec_C2Tuple_PublicKeyTypeZZ_new(number[] elems);
+ public static native boolean LDKCResult_boolLightningErrorZ_result_ok(long arg);
+ public static native boolean LDKCResult_boolLightningErrorZ_get_ok(long arg);
+ public static native number LDKCResult_boolLightningErrorZ_get_err(long arg);
+ public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(number a, number b, number c);
+ // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR tuple);
+ export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(tuple);
+ return nativeResponseValue;
+ }
+ // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR tuple);
+ export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(tuple);
+ return nativeResponseValue;
+ }
+ // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR tuple);
+ export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(tuple: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(tuple);
+ return nativeResponseValue;
+ }
+ public static native long LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(number[] elems);
+ public static native long LDKCVec_NodeAnnouncementZ_new(number[] elems);
+ public static native boolean LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(long arg);
+ public static native Uint8Array LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(long arg);
+ public static native number LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_NonePeerHandleErrorZ_result_ok(long arg);
+ public static native void LDKCResult_NonePeerHandleErrorZ_get_ok(long arg);
+ public static native number LDKCResult_NonePeerHandleErrorZ_get_err(long arg);
public static native boolean LDKCResult_boolPeerHandleErrorZ_result_ok(long arg);
public static native boolean LDKCResult_boolPeerHandleErrorZ_get_ok(long arg);
public static native number LDKCResult_boolPeerHandleErrorZ_get_err(long arg);
+
+
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
+
+ export interface LDKAccess {
+ get_utxo (genesis_hash: Uint8Array, short_channel_id: number): number;
+ }
+
+ export function LDKAccess_new(impl: LDKAccess): number {
+ throw new Error('unimplemented'); // TODO: bind to WASM
+ }
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
+
+
+ // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
+ export function Access_get_utxo(this_arg: number, genesis_hash: Uint8Array, short_channel_id: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Access_get_utxo(this_arg, encodeArray(genesis_hash), short_channel_id);
+ return nativeResponseValue;
+ }
+ public static class LDKCOption_AccessZ {
+ private LDKCOption_AccessZ() {}
+ export class Some extends LDKCOption_AccessZ {
+ public number some;
+ Some(number some) { this.some = some; }
+ }
+ export class None extends LDKCOption_AccessZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_AccessZ.init(); }
+ public static native LDKCOption_AccessZ LDKCOption_AccessZ_ref_from_ptr(long ptr);
public static native boolean LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_err(long arg);
public static native boolean LDKCResult_ClosingSignedDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_ClosingSignedDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_ClosingSignedDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(long arg);
public static native boolean LDKCResult_CommitmentSignedDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_CommitmentSignedDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_CommitmentSignedDecodeErrorZ_get_err(long arg);
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
+
+ export interface LDKFilter {
+ register_tx (txid: Uint8Array, script_pubkey: Uint8Array): void;
+ register_output (output: number): number;
+ }
+
+ export function LDKFilter_new(impl: LDKFilter): number {
+ throw new Error('unimplemented'); // TODO: bind to WASM
+ }
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
+
+
+ // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
+ export function Filter_register_tx(this_arg: number, txid: Uint8Array, script_pubkey: Uint8Array): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Filter_register_tx(this_arg, encodeArray(txid), encodeArray(script_pubkey));
+ // debug statements here
+ }
+ // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
+ export function Filter_register_output(this_arg: number, output: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Filter_register_output(this_arg, output);
+ return nativeResponseValue;
+ }
+ public static class LDKCOption_FilterZ {
+ private LDKCOption_FilterZ() {}
+ export class Some extends LDKCOption_FilterZ {
+ public number some;
+ Some(number some) { this.some = some; }
+ }
+ export class None extends LDKCOption_FilterZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_FilterZ.init(); }
+ public static native LDKCOption_FilterZ LDKCOption_FilterZ_ref_from_ptr(long ptr);
+
+
+
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
export interface LDKMessageSendEventsProvider {
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, struct LDKEvent event
+ // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
export function EventHandler_handle_event(this_arg: number, event: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
-// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
-
- export interface LDKAccess {
- get_utxo (genesis_hash: Uint8Array, short_channel_id: number): number;
- }
-
- export function LDKAccess_new(impl: LDKAccess): number {
- throw new Error('unimplemented'); // TODO: bind to WASM
- }
-
-// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
-
-
- // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
- export function Access_get_utxo(this_arg: number, genesis_hash: Uint8Array, short_channel_id: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Access_get_utxo(this_arg, encodeArray(genesis_hash), short_channel_id);
- return nativeResponseValue;
- }
-
-
-
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
export interface LDKListen {
-// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
-
- export interface LDKFilter {
- register_tx (txid: Uint8Array, script_pubkey: Uint8Array): void;
- register_output (output: number): number;
- }
-
- export function LDKFilter_new(impl: LDKFilter): number {
- throw new Error('unimplemented'); // TODO: bind to WASM
- }
-
-// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
-
-
- // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
- export function Filter_register_tx(this_arg: number, txid: Uint8Array, script_pubkey: Uint8Array): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Filter_register_tx(this_arg, encodeArray(txid), encodeArray(script_pubkey));
- // debug statements here
- }
- // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
- export function Filter_register_output(this_arg: number, output: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Filter_register_output(this_arg, output);
- return nativeResponseValue;
- }
-
-
-
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
export interface LDKPersist {
handle_node_announcement (msg: number): number;
handle_channel_announcement (msg: number): number;
handle_channel_update (msg: number): number;
- handle_htlc_fail_channel_update (update: number): void;
get_next_channel_announcements (starting_point: number, batch_amount: number): number[];
get_next_node_announcements (starting_point: Uint8Array, batch_amount: number): number[];
sync_routing_table (their_node_id: Uint8Array, init: number): void;
const nativeResponseValue = wasm.RoutingMessageHandler_handle_channel_update(this_arg, msg);
return nativeResponseValue;
}
- // void RoutingMessageHandler_handle_htlc_fail_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKHTLCFailChannelUpdate *NONNULL_PTR update
- export function RoutingMessageHandler_handle_htlc_fail_channel_update(this_arg: number, update: number): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.RoutingMessageHandler_handle_htlc_fail_channel_update(this_arg, update);
- // debug statements here
- }
// LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: number, batch_amount: number): number[] {
if(!isWasmInitialized) {
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
+
+ export interface LDKCustomMessageReader {
+ read (message_type: number, buffer: Uint8Array): number;
+ }
+
+ export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
+ throw new Error('unimplemented'); // TODO: bind to WASM
+ }
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
+
+
+ // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
+ export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CustomMessageReader_read(this_arg, message_type, encodeArray(buffer));
+ return nativeResponseValue;
+ }
+
+
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
+
+ export interface LDKCustomMessageHandler {
+ handle_custom_message (msg: number, sender_node_id: Uint8Array): number;
+ get_and_clear_pending_msg (): number[];
+ }
+
+ export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
+ throw new Error('unimplemented'); // TODO: bind to WASM
+ }
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
+
+
+ // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
+ export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CustomMessageHandler_handle_custom_message(this_arg, msg, encodeArray(sender_node_id));
+ return nativeResponseValue;
+ }
+ // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
+ export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CustomMessageHandler_get_and_clear_pending_msg(this_arg);
+ return nativeResponseValue;
+ }
+
+
+
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
export interface LDKSocketDescriptor {
const nativeResponseValue = wasm.Transaction_free(encodeArray(_res));
// debug statements here
}
+ // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
+ export function TxOut_new(script_pubkey: Uint8Array, value: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TxOut_new(encodeArray(script_pubkey), value);
+ return nativeResponseValue;
+ }
// void TxOut_free(struct LDKTxOut _res);
export function TxOut_free(_res: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
+ // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
+ export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TrustedClosingTransactionNoneZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
+ export function CResult_TrustedClosingTransactionNoneZ_err(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TrustedClosingTransactionNoneZ_err();
+ return nativeResponseValue;
+ }
+ // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
+ export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TrustedClosingTransactionNoneZ_free(_res);
+ // debug statements here
+ }
// struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
- export function CResult_NoneErrorZ_ok(): number {
+ // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
+ export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneErrorZ_ok();
+ const nativeResponseValue = wasm.CResult_ShutdownScriptDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
- export function CResult_NoneErrorZ_err(e: IOError): number {
+ // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_ShutdownScriptDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
- export function CResult_NoneErrorZ_free(_res: number): void {
+ // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
+ export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ShutdownScriptDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
- export function CResult_NoneErrorZ_clone(orig: number): number {
+ // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_ShutdownScriptDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
- export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
+ export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RouteHopDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
+ export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RouteHopDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
return nativeResponseValue;
}
- // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
- export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
+ // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
+ export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RouteHopDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
// debug statements here
}
- // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
+ export function CResult_NoneErrorZ_ok(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneErrorZ_ok();
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
+ export function CResult_NoneErrorZ_err(e: IOError): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
+ export function CResult_NoneErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
+ export function CResult_NoneErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
+ export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteHopDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteHopDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
+ export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteHopDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
const nativeResponseValue = wasm.COption_C2Tuple_usizeTransactionZZ_clone(orig);
return nativeResponseValue;
}
+ // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
+ export function COption_NetworkUpdateZ_some(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_NetworkUpdateZ_some(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
+ export function COption_NetworkUpdateZ_none(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_NetworkUpdateZ_none();
+ return nativeResponseValue;
+ }
+ // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
+ export function COption_NetworkUpdateZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_NetworkUpdateZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
+ export function COption_NetworkUpdateZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_NetworkUpdateZ_clone(orig);
+ return nativeResponseValue;
+ }
// void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
export function CVec_SpendableOutputDescriptorZ_free(_res: number[]): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
+ // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
+ export function CResult_NoneNoneZ_ok(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneNoneZ_ok();
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
+ export function CResult_NoneNoneZ_err(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneNoneZ_err();
+ return nativeResponseValue;
+ }
+ // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
+ export function CResult_NoneNoneZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneNoneZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
+ export function CResult_NoneNoneZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneNoneZ_clone(orig);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TransactionNoneZ_clone(orig);
return nativeResponseValue;
}
+ // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
+ export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_clone(orig);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
export function C2Tuple_BlockHashChannelMonitorZ_new(a: Uint8Array, b: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res);
// debug statements here
}
+ // struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(const struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *NONNULL_PTR orig);
+ export function CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
+ export function COption_u16Z_some(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_u16Z_some(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCOption_u16Z COption_u16Z_none(void);
+ export function COption_u16Z_none(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_u16Z_none();
+ return nativeResponseValue;
+ }
+ // void COption_u16Z_free(struct LDKCOption_u16Z _res);
+ export function COption_u16Z_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_u16Z_free(_res);
+ // debug statements here
+ }
+ // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
+ export function COption_u16Z_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_u16Z_clone(orig);
+ return nativeResponseValue;
+ }
// struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
export function CResult_NoneAPIErrorZ_ok(): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_clone(orig);
return nativeResponseValue;
}
+ // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
+ export function CResult_PaymentHashPaymentSendFailureZ_ok(o: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PaymentHashPaymentSendFailureZ_ok(encodeArray(o));
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
+ export function CResult_PaymentHashPaymentSendFailureZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PaymentHashPaymentSendFailureZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_PaymentHashPaymentSendFailureZ_free(struct LDKCResult_PaymentHashPaymentSendFailureZ _res);
+ export function CResult_PaymentHashPaymentSendFailureZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PaymentHashPaymentSendFailureZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_PaymentHashPaymentSendFailureZ CResult_PaymentHashPaymentSendFailureZ_clone(const struct LDKCResult_PaymentHashPaymentSendFailureZ *NONNULL_PTR orig);
+ export function CResult_PaymentHashPaymentSendFailureZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_PaymentHashPaymentSendFailureZ_clone(orig);
+ return nativeResponseValue;
+ }
// void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
export function CVec_NetAddressZ_free(_res: number[]): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
+ // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
+ export function COption_TypeZ_some(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_TypeZ_some(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCOption_TypeZ COption_TypeZ_none(void);
+ export function COption_TypeZ_none(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_TypeZ_none();
+ return nativeResponseValue;
+ }
+ // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
+ export function COption_TypeZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_TypeZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
+ export function COption_TypeZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_TypeZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
+ export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_TypeZDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_TypeZDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
+ export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_TypeZDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_COption_TypeZDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
// struct LDKCResult_SiPrefixNoneZ CResult_SiPrefixNoneZ_ok(enum LDKSiPrefix o);
export function CResult_SiPrefixNoneZ_ok(o: SiPrefix): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
// debug statements here
}
+ // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
+ export function CVec_BalanceZ_free(_res: number[]): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CVec_BalanceZ_free(_res);
+ // debug statements here
+ }
// struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
// debug statements here
}
+ // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
+ export function CResult_NoneLightningErrorZ_ok(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_ok();
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
+ export function CResult_NoneLightningErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
+ export function CResult_NoneLightningErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
+ export function CResult_NoneLightningErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
+ export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_PublicKeyTypeZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
+ export function C2Tuple_PublicKeyTypeZ_new(a: Uint8Array, b: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_PublicKeyTypeZ_new(encodeArray(a), b);
+ return nativeResponseValue;
+ }
+ // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
+ export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_PublicKeyTypeZ_free(_res);
+ // debug statements here
+ }
+ // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
+ export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number[]): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
+ // debug statements here
+ }
// struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
export function CResult_boolLightningErrorZ_ok(o: boolean): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CVec_NodeAnnouncementZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
- export function CResult_NoneLightningErrorZ_ok(): number {
+ // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
+ export function CVec_PublicKeyZ_free(_res: Uint8Array[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_ok();
- return nativeResponseValue;
- }
- // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
- export function CResult_NoneLightningErrorZ_err(e: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_err(e);
- return nativeResponseValue;
- }
- // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
- export function CResult_NoneLightningErrorZ_free(_res: number): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_free(_res);
- // debug statements here
- }
- // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
- export function CResult_NoneLightningErrorZ_clone(orig: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_clone(orig);
- return nativeResponseValue;
- }
- // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
- export function CVec_PublicKeyZ_free(_res: Uint8Array[]): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CVec_PublicKeyZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CVec_PublicKeyZ_free(_res);
+ // debug statements here
}
// struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: Uint8Array): number {
const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_clone(orig);
return nativeResponseValue;
}
+ // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
+ export function COption_AccessZ_some(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_AccessZ_some(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCOption_AccessZ COption_AccessZ_none(void);
+ export function COption_AccessZ_none(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_AccessZ_none();
+ return nativeResponseValue;
+ }
+ // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
+ export function COption_AccessZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_AccessZ_free(_res);
+ // debug statements here
+ }
// struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
export function CResult_DirectionalChannelInfoDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
+ // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
+ export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
+ export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
// struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_InvoiceSignOrCreationErrorZ_clone(orig);
return nativeResponseValue;
}
- // void Event_free(struct LDKEvent this_ptr);
- export function Event_free(this_ptr: number): void {
+ // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
+ export function COption_FilterZ_some(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Event_free(this_ptr);
- // debug statements here
+ const nativeResponseValue = wasm.COption_FilterZ_some(o);
+ return nativeResponseValue;
}
- // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
- export function Event_clone(orig: number): number {
+ // struct LDKCOption_FilterZ COption_FilterZ_none(void);
+ export function COption_FilterZ_none(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Event_clone(orig);
+ const nativeResponseValue = wasm.COption_FilterZ_none();
return nativeResponseValue;
}
- // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
- export function Event_write(obj: number): Uint8Array {
+ // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
+ export function COption_FilterZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Event_write(obj);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.COption_FilterZ_free(_res);
+ // debug statements here
}
- // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
- export function MessageSendEvent_free(this_ptr: number): void {
+ // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
+ export function PaymentPurpose_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.MessageSendEvent_free(this_ptr);
+ const nativeResponseValue = wasm.PaymentPurpose_free(this_ptr);
// debug statements here
}
- // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
- export function MessageSendEvent_clone(orig: number): number {
+ // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
+ export function PaymentPurpose_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.MessageSendEvent_clone(orig);
+ const nativeResponseValue = wasm.PaymentPurpose_clone(orig);
return nativeResponseValue;
}
- // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
- export function MessageSendEventsProvider_free(this_ptr: number): void {
+ // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret, uint64_t user_payment_id);
+ export function PaymentPurpose_invoice_payment(payment_preimage: Uint8Array, payment_secret: Uint8Array, user_payment_id: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.MessageSendEventsProvider_free(this_ptr);
- // debug statements here
+ const nativeResponseValue = wasm.PaymentPurpose_invoice_payment(encodeArray(payment_preimage), encodeArray(payment_secret), user_payment_id);
+ return nativeResponseValue;
}
- // void EventsProvider_free(struct LDKEventsProvider this_ptr);
- export function EventsProvider_free(this_ptr: number): void {
+ // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
+ export function PaymentPurpose_spontaneous_payment(a: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.EventsProvider_free(this_ptr);
- // debug statements here
+ const nativeResponseValue = wasm.PaymentPurpose_spontaneous_payment(encodeArray(a));
+ return nativeResponseValue;
}
- // void EventHandler_free(struct LDKEventHandler this_ptr);
- export function EventHandler_free(this_ptr: number): void {
+ // void ClosureReason_free(struct LDKClosureReason this_ptr);
+ export function ClosureReason_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.EventHandler_free(this_ptr);
+ const nativeResponseValue = wasm.ClosureReason_free(this_ptr);
// debug statements here
}
- // void APIError_free(struct LDKAPIError this_ptr);
- export function APIError_free(this_ptr: number): void {
+ // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
+ export function ClosureReason_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.APIError_free(this_ptr);
- // debug statements here
+ const nativeResponseValue = wasm.ClosureReason_clone(orig);
+ return nativeResponseValue;
}
- // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
- export function APIError_clone(orig: number): number {
+ // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
+ export function ClosureReason_counterparty_force_closed(peer_msg: String): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.APIError_clone(orig);
+ const nativeResponseValue = wasm.ClosureReason_counterparty_force_closed(peer_msg);
return nativeResponseValue;
}
- // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, struct LDKSecretKey sk);
- export function sign(msg: Uint8Array, sk: Uint8Array): number {
+ // struct LDKClosureReason ClosureReason_holder_force_closed(void);
+ export function ClosureReason_holder_force_closed(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.sign(encodeArray(msg), encodeArray(sk));
+ const nativeResponseValue = wasm.ClosureReason_holder_force_closed();
return nativeResponseValue;
}
- // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
- export function recover_pk(msg: Uint8Array, sig: String): number {
+ // struct LDKClosureReason ClosureReason_cooperative_closure(void);
+ export function ClosureReason_cooperative_closure(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.recover_pk(encodeArray(msg), sig);
+ const nativeResponseValue = wasm.ClosureReason_cooperative_closure();
return nativeResponseValue;
}
- // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
- export function verify(msg: Uint8Array, sig: String, pk: Uint8Array): boolean {
+ // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
+ export function ClosureReason_commitment_tx_confirmed(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.verify(encodeArray(msg), sig, encodeArray(pk));
+ const nativeResponseValue = wasm.ClosureReason_commitment_tx_confirmed();
return nativeResponseValue;
}
- // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
- export function Level_clone(orig: number): Level {
+ // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
+ export function ClosureReason_processing_error(err: String): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Level_clone(orig);
+ const nativeResponseValue = wasm.ClosureReason_processing_error(err);
return nativeResponseValue;
}
- // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
- export function Level_eq(a: number, b: number): boolean {
+ // struct LDKClosureReason ClosureReason_disconnected_peer(void);
+ export function ClosureReason_disconnected_peer(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Level_eq(a, b);
+ const nativeResponseValue = wasm.ClosureReason_disconnected_peer();
return nativeResponseValue;
}
- // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
- export function Level_hash(o: number): number {
+ // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
+ export function ClosureReason_outdated_channel_manager(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Level_hash(o);
+ const nativeResponseValue = wasm.ClosureReason_outdated_channel_manager();
return nativeResponseValue;
}
- // MUST_USE_RES enum LDKLevel Level_max(void);
- export function Level_max(): Level {
+ // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
+ export function ClosureReason_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Level_max();
- return nativeResponseValue;
+ const nativeResponseValue = wasm.ClosureReason_write(obj);
+ return decodeArray(nativeResponseValue);
}
- // void Logger_free(struct LDKLogger this_ptr);
- export function Logger_free(this_ptr: number): void {
+ // void Event_free(struct LDKEvent this_ptr);
+ export function Event_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Logger_free(this_ptr);
+ const nativeResponseValue = wasm.Event_free(this_ptr);
// debug statements here
}
- // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
- export function ChannelHandshakeConfig_free(this_obj: number): void {
+ // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
+ export function Event_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeConfig_free(this_obj);
- // debug statements here
+ const nativeResponseValue = wasm.Event_clone(orig);
+ return nativeResponseValue;
}
- // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
- export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
+ // struct LDKEvent Event_funding_generation_ready(struct LDKThirtyTwoBytes temporary_channel_id, uint64_t channel_value_satoshis, struct LDKCVec_u8Z output_script, uint64_t user_channel_id);
+ export function Event_funding_generation_ready(temporary_channel_id: Uint8Array, channel_value_satoshis: number, output_script: Uint8Array, user_channel_id: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeConfig_get_minimum_depth(this_ptr);
+ const nativeResponseValue = wasm.Event_funding_generation_ready(encodeArray(temporary_channel_id), channel_value_satoshis, encodeArray(output_script), user_channel_id);
return nativeResponseValue;
}
- // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
- export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
+ // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amt, struct LDKPaymentPurpose purpose);
+ export function Event_payment_received(payment_hash: Uint8Array, amt: number, purpose: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.Event_payment_received(encodeArray(payment_hash), amt, purpose);
+ return nativeResponseValue;
}
- // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
- export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
+ // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_preimage);
+ export function Event_payment_sent(payment_preimage: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
+ const nativeResponseValue = wasm.Event_payment_sent(encodeArray(payment_preimage));
return nativeResponseValue;
}
- // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
- export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
+ // struct LDKEvent Event_payment_path_failed(struct LDKThirtyTwoBytes payment_hash, bool rejected_by_dest, struct LDKCOption_NetworkUpdateZ network_update, bool all_paths_failed, struct LDKCVec_RouteHopZ path);
+ export function Event_payment_path_failed(payment_hash: Uint8Array, rejected_by_dest: boolean, network_update: number, all_paths_failed: boolean, path: number[]): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.Event_payment_path_failed(encodeArray(payment_hash), rejected_by_dest, network_update, all_paths_failed, path);
+ return nativeResponseValue;
}
- // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
- export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): number {
+ // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
+ export function Event_pending_htlcs_forwardable(time_forwardable: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
+ const nativeResponseValue = wasm.Event_pending_htlcs_forwardable(time_forwardable);
return nativeResponseValue;
}
- // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
- export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: number): void {
+ // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
+ export function Event_spendable_outputs(outputs: number[]): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.Event_spendable_outputs(outputs);
+ return nativeResponseValue;
}
- // 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);
- export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: number): number {
+ // struct LDKEvent Event_payment_forwarded(struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx);
+ export function Event_payment_forwarded(fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg);
+ const nativeResponseValue = wasm.Event_payment_forwarded(fee_earned_msat, claim_from_onchain_tx);
return nativeResponseValue;
}
- // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
- export function ChannelHandshakeConfig_clone(orig: number): number {
+ // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, struct LDKClosureReason reason);
+ export function Event_channel_closed(channel_id: Uint8Array, reason: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeConfig_clone(orig);
+ const nativeResponseValue = wasm.Event_channel_closed(encodeArray(channel_id), reason);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
- export function ChannelHandshakeConfig_default(): number {
+ // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
+ export function Event_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeConfig_default();
- return nativeResponseValue;
+ const nativeResponseValue = wasm.Event_write(obj);
+ return decodeArray(nativeResponseValue);
}
- // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
- export function ChannelHandshakeLimits_free(this_obj: number): void {
+ // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
+ export function MessageSendEvent_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_free(this_obj);
+ const nativeResponseValue = wasm.MessageSendEvent_free(this_ptr);
// debug statements here
}
- // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
- export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): number {
+ // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
+ export function MessageSendEvent_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
+ const nativeResponseValue = wasm.MessageSendEvent_clone(orig);
return nativeResponseValue;
}
- // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
- export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: number): void {
+ // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
+ export function MessageSendEvent_send_accept_channel(node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.MessageSendEvent_send_accept_channel(encodeArray(node_id), msg);
+ return nativeResponseValue;
}
- // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
- export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): number {
+ // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
+ export function MessageSendEvent_send_open_channel(node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
+ const nativeResponseValue = wasm.MessageSendEvent_send_open_channel(encodeArray(node_id), msg);
return nativeResponseValue;
}
- // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
- export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: number): void {
+ // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
+ export function MessageSendEvent_send_funding_created(node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.MessageSendEvent_send_funding_created(encodeArray(node_id), msg);
+ return nativeResponseValue;
}
- // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
- export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): number {
+ // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
+ export function MessageSendEvent_send_funding_signed(node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
+ const nativeResponseValue = wasm.MessageSendEvent_send_funding_signed(encodeArray(node_id), msg);
return nativeResponseValue;
}
- // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
- export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: number): void {
+ // struct LDKMessageSendEvent MessageSendEvent_send_funding_locked(struct LDKPublicKey node_id, struct LDKFundingLocked msg);
+ export function MessageSendEvent_send_funding_locked(node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.MessageSendEvent_send_funding_locked(encodeArray(node_id), msg);
+ return nativeResponseValue;
}
- // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
- export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): number {
+ // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
+ export function MessageSendEvent_send_announcement_signatures(node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
+ const nativeResponseValue = wasm.MessageSendEvent_send_announcement_signatures(encodeArray(node_id), msg);
return nativeResponseValue;
}
- // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
- export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: number): void {
+ // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
+ export function MessageSendEvent_update_htlcs(node_id: Uint8Array, updates: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.MessageSendEvent_update_htlcs(encodeArray(node_id), updates);
+ return nativeResponseValue;
}
- // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
- export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
+ // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
+ export function MessageSendEvent_send_revoke_and_ack(node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
+ const nativeResponseValue = wasm.MessageSendEvent_send_revoke_and_ack(encodeArray(node_id), msg);
return nativeResponseValue;
}
- // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
- export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
+ // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
+ export function MessageSendEvent_send_closing_signed(node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.MessageSendEvent_send_closing_signed(encodeArray(node_id), msg);
+ return nativeResponseValue;
}
- // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
- export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
+ // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
+ export function MessageSendEvent_send_shutdown(node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
+ const nativeResponseValue = wasm.MessageSendEvent_send_shutdown(encodeArray(node_id), msg);
return nativeResponseValue;
}
- // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
- export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
+ // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
+ export function MessageSendEvent_send_channel_reestablish(node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.MessageSendEvent_send_channel_reestablish(encodeArray(node_id), msg);
+ return nativeResponseValue;
}
- // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
- export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
+ // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
+ export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
+ const nativeResponseValue = wasm.MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
return nativeResponseValue;
}
- // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
- export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
+ // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
+ export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.MessageSendEvent_broadcast_node_announcement(msg);
+ return nativeResponseValue;
}
- // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
- export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
+ // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
+ export function MessageSendEvent_broadcast_channel_update(msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
+ const nativeResponseValue = wasm.MessageSendEvent_broadcast_channel_update(msg);
return nativeResponseValue;
}
- // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
- export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
+ // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
+ export function MessageSendEvent_send_channel_update(node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.MessageSendEvent_send_channel_update(encodeArray(node_id), msg);
+ return nativeResponseValue;
}
- // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_new(uint64_t min_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 force_announced_channel_preference_arg, uint16_t their_to_self_delay_arg);
- export function ChannelHandshakeLimits_new(min_funding_satoshis_arg: number, max_htlc_minimum_msat_arg: number, min_max_htlc_value_in_flight_msat_arg: number, max_channel_reserve_satoshis_arg: number, min_max_accepted_htlcs_arg: number, max_minimum_depth_arg: number, force_announced_channel_preference_arg: boolean, their_to_self_delay_arg: number): number {
+ // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
+ export function MessageSendEvent_handle_error(node_id: Uint8Array, action: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MessageSendEvent_handle_error(encodeArray(node_id), action);
+ return nativeResponseValue;
+ }
+ // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
+ export function MessageSendEvent_send_channel_range_query(node_id: Uint8Array, msg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MessageSendEvent_send_channel_range_query(encodeArray(node_id), msg);
+ return nativeResponseValue;
+ }
+ // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
+ export function MessageSendEvent_send_short_ids_query(node_id: Uint8Array, msg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MessageSendEvent_send_short_ids_query(encodeArray(node_id), msg);
+ return nativeResponseValue;
+ }
+ // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
+ export function MessageSendEvent_send_reply_channel_range(node_id: Uint8Array, msg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MessageSendEvent_send_reply_channel_range(encodeArray(node_id), msg);
+ return nativeResponseValue;
+ }
+ // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
+ export function MessageSendEventsProvider_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MessageSendEventsProvider_free(this_ptr);
+ // debug statements here
+ }
+ // void EventsProvider_free(struct LDKEventsProvider this_ptr);
+ export function EventsProvider_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.EventsProvider_free(this_ptr);
+ // debug statements here
+ }
+ // void EventHandler_free(struct LDKEventHandler this_ptr);
+ export function EventHandler_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.EventHandler_free(this_ptr);
+ // debug statements here
+ }
+ // void APIError_free(struct LDKAPIError this_ptr);
+ export function APIError_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.APIError_free(this_ptr);
+ // debug statements here
+ }
+ // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
+ export function APIError_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.APIError_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
+ export function APIError_apimisuse_error(err: String): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.APIError_apimisuse_error(err);
+ return nativeResponseValue;
+ }
+ // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
+ export function APIError_fee_rate_too_high(err: String, feerate: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.APIError_fee_rate_too_high(err, feerate);
+ return nativeResponseValue;
+ }
+ // struct LDKAPIError APIError_route_error(struct LDKStr err);
+ export function APIError_route_error(err: String): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.APIError_route_error(err);
+ return nativeResponseValue;
+ }
+ // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
+ export function APIError_channel_unavailable(err: String): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.APIError_channel_unavailable(err);
+ return nativeResponseValue;
+ }
+ // struct LDKAPIError APIError_monitor_update_failed(void);
+ export function APIError_monitor_update_failed(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.APIError_monitor_update_failed();
+ return nativeResponseValue;
+ }
+ // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
+ export function APIError_incompatible_shutdown_script(script: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.APIError_incompatible_shutdown_script(script);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
+ export function sign(msg: Uint8Array, sk: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.sign(encodeArray(msg), encodeArray(sk));
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
+ export function recover_pk(msg: Uint8Array, sig: String): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.recover_pk(encodeArray(msg), sig);
+ return nativeResponseValue;
+ }
+ // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
+ export function verify(msg: Uint8Array, sig: String, pk: Uint8Array): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.verify(encodeArray(msg), sig, encodeArray(pk));
+ return nativeResponseValue;
+ }
+ // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
+ export function Level_clone(orig: number): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Level_clone(orig);
+ return nativeResponseValue;
+ }
+ // enum LDKLevel Level_trace(void);
+ export function Level_trace(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Level_trace();
+ return nativeResponseValue;
+ }
+ // enum LDKLevel Level_debug(void);
+ export function Level_debug(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Level_debug();
+ return nativeResponseValue;
+ }
+ // enum LDKLevel Level_info(void);
+ export function Level_info(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Level_info();
+ return nativeResponseValue;
+ }
+ // enum LDKLevel Level_warn(void);
+ export function Level_warn(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Level_warn();
+ return nativeResponseValue;
+ }
+ // enum LDKLevel Level_error(void);
+ export function Level_error(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Level_error();
+ return nativeResponseValue;
+ }
+ // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
+ export function Level_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Level_eq(a, b);
+ return nativeResponseValue;
+ }
+ // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
+ export function Level_hash(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Level_hash(o);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES enum LDKLevel Level_max(void);
+ export function Level_max(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Level_max();
+ return nativeResponseValue;
+ }
+ // void Logger_free(struct LDKLogger this_ptr);
+ export function Logger_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Logger_free(this_ptr);
+ // debug statements here
+ }
+ // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
+ export function ChannelHandshakeConfig_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_free(this_obj);
+ // debug statements here
+ }
+ // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
+ export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_get_minimum_depth(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
+ export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
+ // debug statements here
+ }
+ // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
+ export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
+ export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
+ // debug statements here
+ }
+ // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
+ export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
+ export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
+ // debug statements here
+ }
+ // 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);
+ export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg);
+ return nativeResponseValue;
+ }
+ // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
+ export function ChannelHandshakeConfig_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_clone(orig);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
+ export function ChannelHandshakeConfig_default(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_default();
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
+ export function ChannelHandshakeLimits_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_free(this_obj);
+ // debug statements here
+ }
+ // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
+ export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
+ export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
+ // debug statements here
+ }
+ // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
+ export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
+ export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
+ // debug statements here
+ }
+ // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
+ export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
+ export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
+ // debug statements here
+ }
+ // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
+ export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
+ export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
+ // debug statements here
+ }
+ // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
+ export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
+ export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
+ // debug statements here
+ }
+ // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
+ export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
+ export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
+ // debug statements here
+ }
+ // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
+ export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
+ export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
+ // debug statements here
+ }
+ // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
+ export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
+ export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_new(uint64_t min_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 force_announced_channel_preference_arg, uint16_t their_to_self_delay_arg);
+ export function ChannelHandshakeLimits_new(min_funding_satoshis_arg: number, max_htlc_minimum_msat_arg: number, min_max_htlc_value_in_flight_msat_arg: number, max_channel_reserve_satoshis_arg: number, min_max_accepted_htlcs_arg: number, max_minimum_depth_arg: number, force_announced_channel_preference_arg: boolean, their_to_self_delay_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
const nativeResponseValue = wasm.ChannelConfig_free(this_obj);
// debug statements here
}
- // uint32_t ChannelConfig_get_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
- export function ChannelConfig_get_fee_proportional_millionths(this_ptr: number): number {
+ // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
+ export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelConfig_get_fee_proportional_millionths(this_ptr);
+ const nativeResponseValue = wasm.ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
return nativeResponseValue;
}
- // void ChannelConfig_set_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
- export function ChannelConfig_set_fee_proportional_millionths(this_ptr: number, val: number): void {
+ // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
+ export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelConfig_set_fee_proportional_millionths(this_ptr, val);
+ const nativeResponseValue = wasm.ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
+ // debug statements here
+ }
+ // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
+ export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
+ export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
// debug statements here
}
// uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
+ const nativeResponseValue = wasm.ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
+ export function ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
+ // debug statements here
+ }
+ // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
+ export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
+ export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
+ // debug statements here
+ }
+ // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
+ export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
return nativeResponseValue;
}
- // void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
- export function ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
+ // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
+ export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
+ const nativeResponseValue = wasm.ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
// debug statements here
}
- // MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, uint16_t cltv_expiry_delta_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
- export function ChannelConfig_new(fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean): number {
+ // 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, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg, uint64_t max_dust_htlc_exposure_msat_arg, uint64_t force_close_avoidance_max_fee_satoshis_arg);
+ export function ChannelConfig_new(forwarding_fee_proportional_millionths_arg: number, forwarding_fee_base_msat_arg: number, cltv_expiry_delta_arg: number, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean, max_dust_htlc_exposure_msat_arg: number, force_close_avoidance_max_fee_satoshis_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelConfig_new(fee_proportional_millionths_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
+ const nativeResponseValue = wasm.ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg, max_dust_htlc_exposure_msat_arg, force_close_avoidance_max_fee_satoshis_arg);
return nativeResponseValue;
}
// struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
const nativeResponseValue = wasm.UserConfig_set_channel_options(this_ptr, val);
// debug statements here
}
- // MUST_USE_RES struct LDKUserConfig UserConfig_new(struct LDKChannelHandshakeConfig own_channel_config_arg, struct LDKChannelHandshakeLimits peer_channel_config_limits_arg, struct LDKChannelConfig channel_options_arg);
- export function UserConfig_new(own_channel_config_arg: number, peer_channel_config_limits_arg: number, channel_options_arg: number): number {
+ // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
+ export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
+ return nativeResponseValue;
+ }
+ // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
+ export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKUserConfig UserConfig_new(struct LDKChannelHandshakeConfig own_channel_config_arg, struct LDKChannelHandshakeLimits peer_channel_config_limits_arg, struct LDKChannelConfig channel_options_arg, bool accept_forwards_to_priv_channels_arg);
+ export function UserConfig_new(own_channel_config_arg: number, peer_channel_config_limits_arg: number, channel_options_arg: number, accept_forwards_to_priv_channels_arg: boolean): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.UserConfig_new(own_channel_config_arg, peer_channel_config_limits_arg, channel_options_arg);
+ const nativeResponseValue = wasm.UserConfig_new(own_channel_config_arg, peer_channel_config_limits_arg, channel_options_arg, accept_forwards_to_priv_channels_arg);
return nativeResponseValue;
}
// struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
const nativeResponseValue = wasm.UserConfig_default();
return nativeResponseValue;
}
+ // void BestBlock_free(struct LDKBestBlock this_obj);
+ export function BestBlock_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BestBlock_free(this_obj);
+ // debug statements here
+ }
+ // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
+ export function BestBlock_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BestBlock_clone(orig);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
+ export function BestBlock_from_genesis(network: Network): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BestBlock_from_genesis(network);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
+ export function BestBlock_new(block_hash: Uint8Array, height: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BestBlock_new(encodeArray(block_hash), height);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
+ export function BestBlock_block_hash(this_arg: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BestBlock_block_hash(this_arg);
+ return decodeArray(nativeResponseValue);
+ }
+ // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
+ export function BestBlock_height(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BestBlock_height(this_arg);
+ return nativeResponseValue;
+ }
// enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
export function AccessError_clone(orig: number): AccessError {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.AccessError_clone(orig);
return nativeResponseValue;
}
+ // enum LDKAccessError AccessError_unknown_chain(void);
+ export function AccessError_unknown_chain(): AccessError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.AccessError_unknown_chain();
+ return nativeResponseValue;
+ }
+ // enum LDKAccessError AccessError_unknown_tx(void);
+ export function AccessError_unknown_tx(): AccessError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.AccessError_unknown_tx();
+ return nativeResponseValue;
+ }
// void Access_free(struct LDKAccess this_ptr);
export function Access_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ConfirmationTarget_clone(orig);
return nativeResponseValue;
}
+ // enum LDKConfirmationTarget ConfirmationTarget_background(void);
+ export function ConfirmationTarget_background(): ConfirmationTarget {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ConfirmationTarget_background();
+ return nativeResponseValue;
+ }
+ // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
+ export function ConfirmationTarget_normal(): ConfirmationTarget {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ConfirmationTarget_normal();
+ return nativeResponseValue;
+ }
+ // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
+ export function ConfirmationTarget_high_priority(): ConfirmationTarget {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ConfirmationTarget_high_priority();
+ return nativeResponseValue;
+ }
+ // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
+ export function ConfirmationTarget_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ConfirmationTarget_eq(a, b);
+ return nativeResponseValue;
+ }
// void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
export function FeeEstimator_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChainMonitor_free(this_obj);
// debug statements here
}
- // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKFilter *chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
+ // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
return nativeResponseValue;
}
+ // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
+ export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number[]): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
+ return nativeResponseValue;
+ }
// struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
export function ChainMonitor_as_Listen(this_arg: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelMonitorUpdateErr_clone(orig);
return nativeResponseValue;
}
+ // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
+ export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitorUpdateErr_temporary_failure();
+ return nativeResponseValue;
+ }
+ // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
+ export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitorUpdateErr_permanent_failure();
+ return nativeResponseValue;
+ }
// void MonitorUpdateError_free(struct LDKMonitorUpdateError this_obj);
export function MonitorUpdateError_free(this_obj: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.MonitorEvent_clone(orig);
return nativeResponseValue;
}
+ // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
+ export function MonitorEvent_htlcevent(a: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MonitorEvent_htlcevent(a);
+ return nativeResponseValue;
+ }
+ // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
+ export function MonitorEvent_commitment_tx_confirmed(a: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MonitorEvent_commitment_tx_confirmed(a);
+ return nativeResponseValue;
+ }
// void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
export function HTLCUpdate_free(this_obj: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.HTLCUpdate_read(encodeArray(ser));
return nativeResponseValue;
}
+ // void Balance_free(struct LDKBalance this_ptr);
+ export function Balance_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Balance_free(this_ptr);
+ // debug statements here
+ }
+ // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
+ export function Balance_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Balance_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
+ export function Balance_claimable_on_channel_close(claimable_amount_satoshis: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Balance_claimable_on_channel_close(claimable_amount_satoshis);
+ return nativeResponseValue;
+ }
+ // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
+ export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: number, confirmation_height: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
+ return nativeResponseValue;
+ }
+ // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
+ export function Balance_contentious_claimable(claimable_amount_satoshis: number, timeout_height: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
+ return nativeResponseValue;
+ }
+ // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
+ export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: number, claimable_height: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
+ return nativeResponseValue;
+ }
+ // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
+ export function Balance_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Balance_eq(a, b);
+ return nativeResponseValue;
+ }
// void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
export function ChannelMonitor_free(this_obj: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelMonitor_get_relevant_txids(this_arg);
return nativeResponseValue;
}
+ // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
+ export function ChannelMonitor_current_best_block(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_current_best_block(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
+ export function ChannelMonitor_get_claimable_balances(this_arg: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_get_claimable_balances(this_arg);
+ return nativeResponseValue;
+ }
// void Persist_free(struct LDKPersist this_ptr);
export function Persist_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.SpendableOutputDescriptor_clone(orig);
return nativeResponseValue;
}
+ // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
+ export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SpendableOutputDescriptor_static_output(outpoint, output);
+ return nativeResponseValue;
+ }
+ // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
+ export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SpendableOutputDescriptor_delayed_payment_output(a);
+ return nativeResponseValue;
+ }
+ // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
+ export function SpendableOutputDescriptor_static_payment_output(a: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SpendableOutputDescriptor_static_payment_output(a);
+ return nativeResponseValue;
+ }
// struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
export function SpendableOutputDescriptor_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChainParameters_clone(orig);
return nativeResponseValue;
}
- // void BestBlock_free(struct LDKBestBlock this_obj);
- export function BestBlock_free(this_obj: number): void {
+ // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
+ export function CounterpartyForwardingInfo_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.BestBlock_free(this_obj);
+ const nativeResponseValue = wasm.CounterpartyForwardingInfo_free(this_obj);
// debug statements here
}
- // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
- export function BestBlock_clone(orig: number): number {
+ // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
+ export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.BestBlock_clone(orig);
+ const nativeResponseValue = wasm.CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
- export function BestBlock_from_genesis(network: Network): number {
+ // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
+ export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
+ // debug statements here
+ }
+ // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
+ export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
+ return nativeResponseValue;
+ }
+ // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
+ export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
+ // debug statements here
+ }
+ // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
+ export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
+ return nativeResponseValue;
+ }
+ // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
+ export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
+ // debug statements here
+ }
+ // 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);
+ export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
+ return nativeResponseValue;
+ }
+ // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
+ export function CounterpartyForwardingInfo_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CounterpartyForwardingInfo_clone(orig);
+ return nativeResponseValue;
+ }
+ // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
+ export function ChannelCounterparty_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelCounterparty_free(this_obj);
+ // debug statements here
+ }
+ // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
+ export function ChannelCounterparty_get_node_id(this_ptr: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelCounterparty_get_node_id(this_ptr);
+ return decodeArray(nativeResponseValue);
+ }
+ // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+ export function ChannelCounterparty_set_node_id(this_ptr: number, val: Uint8Array): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelCounterparty_set_node_id(this_ptr, encodeArray(val));
+ // debug statements here
+ }
+ // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
+ export function ChannelCounterparty_get_features(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelCounterparty_get_features(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
+ export function ChannelCounterparty_set_features(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelCounterparty_set_features(this_ptr, val);
+ // debug statements here
+ }
+ // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
+ export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
+ export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
+ // debug statements here
+ }
+ // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
+ export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.BestBlock_from_genesis(network);
+ const nativeResponseValue = wasm.ChannelCounterparty_get_forwarding_info(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
- export function BestBlock_new(block_hash: Uint8Array, height: number): number {
+ // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
+ export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.BestBlock_new(encodeArray(block_hash), height);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.ChannelCounterparty_set_forwarding_info(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
- export function BestBlock_block_hash(this_arg: number): Uint8Array {
+ // 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);
+ export function ChannelCounterparty_new(node_id_arg: Uint8Array, features_arg: number, unspendable_punishment_reserve_arg: number, forwarding_info_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.BestBlock_block_hash(this_arg);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.ChannelCounterparty_new(encodeArray(node_id_arg), features_arg, unspendable_punishment_reserve_arg, forwarding_info_arg);
+ return nativeResponseValue;
}
- // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
- export function BestBlock_height(this_arg: number): number {
+ // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
+ export function ChannelCounterparty_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.BestBlock_height(this_arg);
+ const nativeResponseValue = wasm.ChannelCounterparty_clone(orig);
return nativeResponseValue;
}
// void ChannelDetails_free(struct LDKChannelDetails this_obj);
const nativeResponseValue = wasm.ChannelDetails_set_channel_id(this_ptr, encodeArray(val));
// debug statements here
}
+ // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ export function ChannelDetails_get_counterparty(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelDetails_get_counterparty(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
+ export function ChannelDetails_set_counterparty(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelDetails_set_counterparty(this_ptr, val);
+ // debug statements here
+ }
// struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
export function ChannelDetails_get_funding_txo(this_ptr: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelDetails_set_short_channel_id(this_ptr, val);
// debug statements here
}
- // struct LDKPublicKey ChannelDetails_get_remote_network_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
- export function ChannelDetails_get_remote_network_id(this_ptr: number): Uint8Array {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.ChannelDetails_get_remote_network_id(this_ptr);
- return decodeArray(nativeResponseValue);
- }
- // void ChannelDetails_set_remote_network_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKPublicKey val);
- export function ChannelDetails_set_remote_network_id(this_ptr: number, val: Uint8Array): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.ChannelDetails_set_remote_network_id(this_ptr, encodeArray(val));
- // debug statements here
- }
- // struct LDKInitFeatures ChannelDetails_get_counterparty_features(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
- export function ChannelDetails_get_counterparty_features(this_ptr: number): number {
+ // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelDetails_get_counterparty_features(this_ptr);
+ const nativeResponseValue = wasm.ChannelDetails_get_channel_value_satoshis(this_ptr);
return nativeResponseValue;
}
- // void ChannelDetails_set_counterparty_features(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
- export function ChannelDetails_set_counterparty_features(this_ptr: number, val: number): void {
+ // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
+ export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelDetails_set_counterparty_features(this_ptr, val);
+ const nativeResponseValue = wasm.ChannelDetails_set_channel_value_satoshis(this_ptr, val);
// debug statements here
}
- // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
- export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): number {
+ // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelDetails_get_channel_value_satoshis(this_ptr);
+ const nativeResponseValue = wasm.ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
return nativeResponseValue;
}
- // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
- export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: number): void {
+ // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelDetails_set_channel_value_satoshis(this_ptr, val);
+ const nativeResponseValue = wasm.ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
// debug statements here
}
// uint64_t ChannelDetails_get_user_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
// debug statements here
}
+ // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelDetails_get_confirmations_required(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
+ export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelDetails_set_confirmations_required(this_ptr, val);
+ // debug statements here
+ }
+ // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelDetails_get_force_close_spend_delay(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
+ export function ChannelDetails_set_force_close_spend_delay(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelDetails_set_force_close_spend_delay(this_ptr, val);
+ // debug statements here
+ }
// bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelDetails_set_is_public(this_ptr, val);
// debug statements here
}
+ // MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKCOption_u64Z short_channel_id_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, uint64_t user_id_arg, uint64_t outbound_capacity_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_funding_locked_arg, bool is_usable_arg, bool is_public_arg);
+ export function ChannelDetails_new(channel_id_arg: Uint8Array, counterparty_arg: number, funding_txo_arg: number, short_channel_id_arg: number, channel_value_satoshis_arg: number, unspendable_punishment_reserve_arg: number, user_id_arg: number, outbound_capacity_msat_arg: number, inbound_capacity_msat_arg: number, confirmations_required_arg: number, force_close_spend_delay_arg: number, is_outbound_arg: boolean, is_funding_locked_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelDetails_new(encodeArray(channel_id_arg), counterparty_arg, funding_txo_arg, short_channel_id_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_id_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, force_close_spend_delay_arg, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
export function ChannelDetails_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.PaymentSendFailure_clone(orig);
return nativeResponseValue;
}
+ // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
+ export function PaymentSendFailure_parameter_error(a: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PaymentSendFailure_parameter_error(a);
+ return nativeResponseValue;
+ }
+ // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
+ export function PaymentSendFailure_path_parameter_error(a: number[]): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PaymentSendFailure_path_parameter_error(a);
+ return nativeResponseValue;
+ }
+ // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
+ export function PaymentSendFailure_all_failed_retry_safe(a: number[]): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PaymentSendFailure_all_failed_retry_safe(a);
+ return nativeResponseValue;
+ }
+ // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ a);
+ export function PaymentSendFailure_partial_failure(a: number[]): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PaymentSendFailure_partial_failure(a);
+ return nativeResponseValue;
+ }
// MUST_USE_RES struct LDKChannelManager ChannelManager_new(struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKKeysInterface keys_manager, struct LDKUserConfig config, struct LDKChainParameters params);
export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelManager_close_channel(this_arg, encodeArray(channel_id));
return nativeResponseValue;
}
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel_with_target_feerate(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], uint32_t target_feerate_sats_per_1000_weight);
+ export function ChannelManager_close_channel_with_target_feerate(this_arg: number, channel_id: Uint8Array, target_feerate_sats_per_1000_weight: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelManager_close_channel_with_target_feerate(this_arg, encodeArray(channel_id), target_feerate_sats_per_1000_weight);
+ return nativeResponseValue;
+ }
// MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
export function ChannelManager_force_close_channel(this_arg: number, channel_id: Uint8Array): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelManager_send_payment(this_arg, route, encodeArray(payment_hash), encodeArray(payment_secret));
return nativeResponseValue;
}
+ // MUST_USE_RES struct LDKCResult_PaymentHashPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage);
+ export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelManager_send_spontaneous_payment(this_arg, route, encodeArray(payment_preimage));
+ return nativeResponseValue;
+ }
// 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 LDKTransaction funding_transaction);
export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: Uint8Array, funding_transaction: Uint8Array): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelManager_await_persistable_update(this_arg);
// debug statements here
}
+ // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ export function ChannelManager_current_best_block(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelManager_current_best_block(this_arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Shutdown_clone(orig);
return nativeResponseValue;
}
+ // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
+ export function ClosingSignedFeeRange_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSignedFeeRange_free(this_obj);
+ // debug statements here
+ }
+ // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
+ export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
+ export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
+ // debug statements here
+ }
+ // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
+ export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
+ export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
+ export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: number, max_fee_satoshis_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
+ return nativeResponseValue;
+ }
+ // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
+ export function ClosingSignedFeeRange_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSignedFeeRange_clone(orig);
+ return nativeResponseValue;
+ }
// void ClosingSigned_free(struct LDKClosingSigned this_obj);
export function ClosingSigned_free(this_obj: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ClosingSigned_set_signature(this_ptr, encodeArray(val));
// debug statements here
}
- // MUST_USE_RES struct LDKClosingSigned ClosingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t fee_satoshis_arg, struct LDKSignature signature_arg);
- export function ClosingSigned_new(channel_id_arg: Uint8Array, fee_satoshis_arg: number, signature_arg: Uint8Array): number {
+ // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
+ export function ClosingSigned_get_fee_range(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSigned_get_fee_range(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
+ export function ClosingSigned_set_fee_range(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSigned_set_fee_range(this_ptr, val);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKClosingSigned ClosingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t fee_satoshis_arg, struct LDKSignature signature_arg, struct LDKClosingSignedFeeRange fee_range_arg);
+ export function ClosingSigned_new(channel_id_arg: Uint8Array, fee_satoshis_arg: number, signature_arg: Uint8Array, fee_range_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ClosingSigned_new(encodeArray(channel_id_arg), fee_satoshis_arg, encodeArray(signature_arg));
+ const nativeResponseValue = wasm.ClosingSigned_new(encodeArray(channel_id_arg), fee_satoshis_arg, encodeArray(signature_arg), fee_range_arg);
return nativeResponseValue;
}
// struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
const nativeResponseValue = wasm.NetAddress_clone(orig);
return nativeResponseValue;
}
+ // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
+ export function NetAddress_ipv4(addr: Uint8Array, port: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetAddress_ipv4(encodeArray(addr), port);
+ return nativeResponseValue;
+ }
+ // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
+ export function NetAddress_ipv6(addr: Uint8Array, port: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetAddress_ipv6(encodeArray(addr), port);
+ return nativeResponseValue;
+ }
+ // struct LDKNetAddress NetAddress_onion_v2(struct LDKTenBytes addr, uint16_t port);
+ export function NetAddress_onion_v2(addr: Uint8Array, port: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetAddress_onion_v2(encodeArray(addr), port);
+ return nativeResponseValue;
+ }
+ // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
+ export function NetAddress_onion_v3(ed25519_pubkey: Uint8Array, checksum: number, version: number, port: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetAddress_onion_v3(encodeArray(ed25519_pubkey), checksum, version, port);
+ return nativeResponseValue;
+ }
// struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
export function NetAddress_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ErrorAction_clone(orig);
return nativeResponseValue;
}
+ // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
+ export function ErrorAction_disconnect_peer(msg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ErrorAction_disconnect_peer(msg);
+ return nativeResponseValue;
+ }
+ // struct LDKErrorAction ErrorAction_ignore_error(void);
+ export function ErrorAction_ignore_error(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ErrorAction_ignore_error();
+ return nativeResponseValue;
+ }
+ // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
+ export function ErrorAction_ignore_and_log(a: Level): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ErrorAction_ignore_and_log(a);
+ return nativeResponseValue;
+ }
+ // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
+ export function ErrorAction_send_error_message(msg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ErrorAction_send_error_message(msg);
+ return nativeResponseValue;
+ }
// void LightningError_free(struct LDKLightningError this_obj);
export function LightningError_free(this_obj: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CommitmentUpdate_free(this_obj);
// debug statements here
}
+ // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
+ export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CommitmentUpdate_get_update_add_htlcs(this_ptr);
+ return nativeResponseValue;
+ }
// void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number[]): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
// debug statements here
}
+ // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
+ export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
+ return nativeResponseValue;
+ }
// void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: number, val: number[]): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
// debug statements here
}
+ // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
+ export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CommitmentUpdate_get_update_fail_htlcs(this_ptr);
+ return nativeResponseValue;
+ }
// void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: number, val: number[]): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
// debug statements here
}
+ // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
+ export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
+ return nativeResponseValue;
+ }
// void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: number, val: number[]): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CommitmentUpdate_clone(orig);
return nativeResponseValue;
}
- // void HTLCFailChannelUpdate_free(struct LDKHTLCFailChannelUpdate this_ptr);
- export function HTLCFailChannelUpdate_free(this_ptr: number): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.HTLCFailChannelUpdate_free(this_ptr);
- // debug statements here
- }
- // struct LDKHTLCFailChannelUpdate HTLCFailChannelUpdate_clone(const struct LDKHTLCFailChannelUpdate *NONNULL_PTR orig);
- export function HTLCFailChannelUpdate_clone(orig: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.HTLCFailChannelUpdate_clone(orig);
- return nativeResponseValue;
- }
// void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
export function ChannelMessageHandler_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ClosingSigned_read(encodeArray(ser));
return nativeResponseValue;
}
+ // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
+ export function ClosingSignedFeeRange_write(obj: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSignedFeeRange_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
+ export function ClosingSignedFeeRange_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingSignedFeeRange_read(encodeArray(ser));
+ return nativeResponseValue;
+ }
// struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
export function CommitmentSigned_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.QueryShortChannelIds_write(obj);
return decodeArray(nativeResponseValue);
}
- // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
- export function ReplyShortChannelIdsEnd_read(ser: Uint8Array): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.ReplyShortChannelIdsEnd_read(encodeArray(ser));
- return nativeResponseValue;
- }
// struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
export function ReplyShortChannelIdsEnd_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ReplyShortChannelIdsEnd_write(obj);
return decodeArray(nativeResponseValue);
}
- // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
- export function QueryChannelRange_end_blocknum(this_arg: number): number {
+ // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
+ export function ReplyShortChannelIdsEnd_read(ser: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.QueryChannelRange_end_blocknum(this_arg);
+ const nativeResponseValue = wasm.ReplyShortChannelIdsEnd_read(encodeArray(ser));
return nativeResponseValue;
}
- // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
- export function QueryChannelRange_read(ser: Uint8Array): number {
+ // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
+ export function QueryChannelRange_end_blocknum(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.QueryChannelRange_read(encodeArray(ser));
+ const nativeResponseValue = wasm.QueryChannelRange_end_blocknum(this_arg);
return nativeResponseValue;
}
// struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.QueryChannelRange_write(obj);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.QueryChannelRange_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
+ export function QueryChannelRange_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.QueryChannelRange_read(encodeArray(ser));
+ return nativeResponseValue;
}
// struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
export function ReplyChannelRange_read(ser: Uint8Array): number {
const nativeResponseValue = wasm.ReplyChannelRange_write(obj);
return decodeArray(nativeResponseValue);
}
+ // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
+ export function GossipTimestampFilter_write(obj: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.GossipTimestampFilter_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
// struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
export function GossipTimestampFilter_read(ser: Uint8Array): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.GossipTimestampFilter_read(encodeArray(ser));
return nativeResponseValue;
}
- // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
- export function GossipTimestampFilter_write(obj: number): Uint8Array {
+ // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
+ export function CustomMessageHandler_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.GossipTimestampFilter_write(obj);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.CustomMessageHandler_free(this_ptr);
+ // debug statements here
}
// void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
export function IgnoringMessageHandler_free(this_obj: number): void {
const nativeResponseValue = wasm.IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
return nativeResponseValue;
}
+ // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
+ export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.IgnoringMessageHandler_as_CustomMessageReader(this_arg);
+ return nativeResponseValue;
+ }
+ // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
+ export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
+ return nativeResponseValue;
+ }
// void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
export function ErroringMessageHandler_free(this_obj: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.PeerManager_free(this_obj);
// debug statements here
}
- // MUST_USE_RES struct LDKPeerManager PeerManager_new(struct LDKMessageHandler message_handler, struct LDKSecretKey our_node_secret, const uint8_t (*ephemeral_random_data)[32], struct LDKLogger logger);
- export function PeerManager_new(message_handler: number, our_node_secret: Uint8Array, ephemeral_random_data: Uint8Array, logger: number): number {
+ // MUST_USE_RES struct LDKPeerManager PeerManager_new(struct LDKMessageHandler message_handler, struct LDKSecretKey our_node_secret, const uint8_t (*ephemeral_random_data)[32], struct LDKLogger logger, struct LDKCustomMessageHandler custom_message_handler);
+ export function PeerManager_new(message_handler: number, our_node_secret: Uint8Array, ephemeral_random_data: Uint8Array, logger: number, custom_message_handler: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.PeerManager_new(message_handler, encodeArray(our_node_secret), encodeArray(ephemeral_random_data), logger);
+ const nativeResponseValue = wasm.PeerManager_new(message_handler, encodeArray(our_node_secret), encodeArray(ephemeral_random_data), logger, custom_message_handler);
return nativeResponseValue;
}
// MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
const nativeResponseValue = wasm.build_commitment_secret(encodeArray(commitment_seed), idx);
return decodeArray(nativeResponseValue);
}
+ // 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);
+ export function build_closing_transaction(to_holder_value_sat: number, to_counterparty_value_sat: number, to_holder_script: Uint8Array, to_counterparty_script: Uint8Array, funding_outpoint: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, encodeArray(to_holder_script), encodeArray(to_counterparty_script), funding_outpoint);
+ return decodeArray(nativeResponseValue);
+ }
// struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
export function derive_private_key(per_commitment_point: Uint8Array, base_secret: Uint8Array): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.BuiltCommitmentTransaction_sign(this_arg, encodeArray(funding_key), encodeArray(funding_redeemscript), channel_value_satoshis);
return decodeArray(nativeResponseValue);
}
+ // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
+ export function ClosingTransaction_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingTransaction_free(this_obj);
+ // debug statements here
+ }
+ // 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);
+ export function ClosingTransaction_new(to_holder_value_sat: number, to_counterparty_value_sat: number, to_holder_script: Uint8Array, to_counterparty_script: Uint8Array, funding_outpoint: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, encodeArray(to_holder_script), encodeArray(to_counterparty_script), funding_outpoint);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
+ export function ClosingTransaction_trust(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingTransaction_trust(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
+ export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingTransaction_verify(this_arg, funding_outpoint);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
+ export function ClosingTransaction_to_holder_value_sat(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingTransaction_to_holder_value_sat(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
+ export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingTransaction_to_counterparty_value_sat(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
+ export function ClosingTransaction_to_holder_script(this_arg: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingTransaction_to_holder_script(this_arg);
+ return decodeArray(nativeResponseValue);
+ }
+ // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
+ export function ClosingTransaction_to_counterparty_script(this_arg: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ClosingTransaction_to_counterparty_script(this_arg);
+ return decodeArray(nativeResponseValue);
+ }
+ // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
+ export function TrustedClosingTransaction_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TrustedClosingTransaction_free(this_obj);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
+ export function TrustedClosingTransaction_built_transaction(this_arg: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TrustedClosingTransaction_built_transaction(this_arg);
+ return decodeArray(nativeResponseValue);
+ }
+ // 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);
+ export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: Uint8Array, channel_value_satoshis: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TrustedClosingTransaction_get_sighash_all(this_arg, encodeArray(funding_redeemscript), channel_value_satoshis);
+ return decodeArray(nativeResponseValue);
+ }
+ // MUST_USE_RES struct LDKSignature TrustedClosingTransaction_sign(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
+ export function TrustedClosingTransaction_sign(this_arg: number, funding_key: Uint8Array, funding_redeemscript: Uint8Array, channel_value_satoshis: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TrustedClosingTransaction_sign(this_arg, encodeArray(funding_key), encodeArray(funding_redeemscript), channel_value_satoshis);
+ return decodeArray(nativeResponseValue);
+ }
// void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
export function CommitmentTransaction_free(this_obj: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.InitFeatures_known();
return nativeResponseValue;
}
+ // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
+ export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InitFeatures_requires_unknown_bits(this_arg);
+ return nativeResponseValue;
+ }
// MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
export function NodeFeatures_empty(): number {
if(!isWasmInitialized) {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NodeFeatures_known();
- return nativeResponseValue;
+ const nativeResponseValue = wasm.NodeFeatures_known();
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
+ export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NodeFeatures_requires_unknown_bits(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
+ export function ChannelFeatures_empty(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelFeatures_empty();
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
+ export function ChannelFeatures_known(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelFeatures_known();
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
+ export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelFeatures_requires_unknown_bits(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
+ export function InvoiceFeatures_empty(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_empty();
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
+ export function InvoiceFeatures_known(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_known();
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
+ export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_requires_unknown_bits(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
+ export function InitFeatures_supports_payment_secret(this_arg: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InitFeatures_supports_payment_secret(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
+ export function NodeFeatures_supports_payment_secret(this_arg: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NodeFeatures_supports_payment_secret(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
+ export function InvoiceFeatures_supports_payment_secret(this_arg: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_supports_payment_secret(this_arg);
+ return nativeResponseValue;
+ }
+ // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
+ export function InitFeatures_write(obj: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InitFeatures_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
+ export function NodeFeatures_write(obj: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NodeFeatures_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
+ export function ChannelFeatures_write(obj: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelFeatures_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
+ export function InvoiceFeatures_write(obj: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
+ export function InitFeatures_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InitFeatures_read(encodeArray(ser));
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
+ export function NodeFeatures_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NodeFeatures_read(encodeArray(ser));
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
+ export function ChannelFeatures_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelFeatures_read(encodeArray(ser));
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
+ export function InvoiceFeatures_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_read(encodeArray(ser));
+ return nativeResponseValue;
+ }
+ // void ShutdownScript_free(struct LDKShutdownScript this_obj);
+ export function ShutdownScript_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ShutdownScript_free(this_obj);
+ // debug statements here
+ }
+ // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
+ export function ShutdownScript_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ShutdownScript_clone(orig);
+ return nativeResponseValue;
+ }
+ // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
+ export function InvalidShutdownScript_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvalidShutdownScript_free(this_obj);
+ // debug statements here
+ }
+ // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
+ export function InvalidShutdownScript_get_script(this_ptr: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvalidShutdownScript_get_script(this_ptr);
+ return decodeArray(nativeResponseValue);
}
- // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
- export function ChannelFeatures_empty(): number {
+ // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
+ export function InvalidShutdownScript_set_script(this_ptr: number, val: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelFeatures_empty();
- return nativeResponseValue;
+ const nativeResponseValue = wasm.InvalidShutdownScript_set_script(this_ptr, encodeArray(val));
+ // debug statements here
}
- // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
- export function ChannelFeatures_known(): number {
+ // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
+ export function InvalidShutdownScript_new(script_arg: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelFeatures_known();
+ const nativeResponseValue = wasm.InvalidShutdownScript_new(encodeArray(script_arg));
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
- export function InvoiceFeatures_empty(): number {
+ // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
+ export function ShutdownScript_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InvoiceFeatures_empty();
- return nativeResponseValue;
+ const nativeResponseValue = wasm.ShutdownScript_write(obj);
+ return decodeArray(nativeResponseValue);
}
- // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
- export function InvoiceFeatures_known(): number {
+ // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
+ export function ShutdownScript_read(ser: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InvoiceFeatures_known();
+ const nativeResponseValue = wasm.ShutdownScript_read(encodeArray(ser));
return nativeResponseValue;
}
- // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
- export function InitFeatures_supports_payment_secret(this_arg: number): boolean {
+ // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2pkh(const uint8_t (*pubkey_hash)[20]);
+ export function ShutdownScript_new_p2pkh(pubkey_hash: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InitFeatures_supports_payment_secret(this_arg);
+ const nativeResponseValue = wasm.ShutdownScript_new_p2pkh(encodeArray(pubkey_hash));
return nativeResponseValue;
}
- // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
- export function NodeFeatures_supports_payment_secret(this_arg: number): boolean {
+ // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2sh(const uint8_t (*script_hash)[20]);
+ export function ShutdownScript_new_p2sh(script_hash: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NodeFeatures_supports_payment_secret(this_arg);
+ const nativeResponseValue = wasm.ShutdownScript_new_p2sh(encodeArray(script_hash));
return nativeResponseValue;
}
- // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
- export function InvoiceFeatures_supports_payment_secret(this_arg: number): boolean {
+ // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
+ export function ShutdownScript_new_p2wpkh(pubkey_hash: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InvoiceFeatures_supports_payment_secret(this_arg);
+ const nativeResponseValue = wasm.ShutdownScript_new_p2wpkh(encodeArray(pubkey_hash));
return nativeResponseValue;
}
- // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
- export function InitFeatures_write(obj: number): Uint8Array {
+ // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
+ export function ShutdownScript_new_p2wsh(script_hash: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InitFeatures_write(obj);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.ShutdownScript_new_p2wsh(encodeArray(script_hash));
+ return nativeResponseValue;
}
- // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
- export function NodeFeatures_write(obj: number): Uint8Array {
+ // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(uint8_t version, struct LDKu8slice program);
+ export function ShutdownScript_new_witness_program(version: number, program: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NodeFeatures_write(obj);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.ShutdownScript_new_witness_program(version, encodeArray(program));
+ return nativeResponseValue;
}
- // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
- export function ChannelFeatures_write(obj: number): Uint8Array {
+ // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
+ export function ShutdownScript_into_inner(this_arg: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelFeatures_write(obj);
+ const nativeResponseValue = wasm.ShutdownScript_into_inner(this_arg);
return decodeArray(nativeResponseValue);
}
- // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
- export function InvoiceFeatures_write(obj: number): Uint8Array {
+ // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
+ export function ShutdownScript_as_legacy_pubkey(this_arg: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InvoiceFeatures_write(obj);
+ const nativeResponseValue = wasm.ShutdownScript_as_legacy_pubkey(this_arg);
return decodeArray(nativeResponseValue);
}
- // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
- export function InitFeatures_read(ser: Uint8Array): number {
+ // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
+ export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InitFeatures_read(encodeArray(ser));
+ const nativeResponseValue = wasm.ShutdownScript_is_compatible(this_arg, features);
return nativeResponseValue;
}
- // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
- export function NodeFeatures_read(ser: Uint8Array): number {
+ // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
+ export function CustomMessageReader_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NodeFeatures_read(encodeArray(ser));
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CustomMessageReader_free(this_ptr);
+ // debug statements here
}
- // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
- export function ChannelFeatures_read(ser: Uint8Array): number {
+ // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
+ export function Type_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelFeatures_read(encodeArray(ser));
+ const nativeResponseValue = wasm.Type_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
- export function InvoiceFeatures_read(ser: Uint8Array): number {
+ // void Type_free(struct LDKType this_ptr);
+ export function Type_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InvoiceFeatures_read(encodeArray(ser));
- return nativeResponseValue;
+ const nativeResponseValue = wasm.Type_free(this_ptr);
+ // debug statements here
}
// void RouteHop_free(struct LDKRouteHop this_obj);
export function RouteHop_free(this_obj: number): void {
const nativeResponseValue = wasm.RouteHop_clone(orig);
return nativeResponseValue;
}
+ // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
+ export function RouteHop_hash(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHop_hash(o);
+ return nativeResponseValue;
+ }
+ // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
+ export function RouteHop_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHop_eq(a, b);
+ return nativeResponseValue;
+ }
// struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
export function RouteHop_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Route_free(this_obj);
// debug statements here
}
+ // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
+ export function Route_get_paths(this_ptr: number): number[][] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Route_get_paths(this_ptr);
+ return nativeResponseValue;
+ }
// void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
export function Route_set_paths(this_ptr: number, val: number[][]): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Route_clone(orig);
return nativeResponseValue;
}
+ // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
+ export function Route_hash(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Route_hash(o);
+ return nativeResponseValue;
+ }
+ // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
+ export function Route_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Route_eq(a, b);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
+ export function Route_get_total_fees(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Route_get_total_fees(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
+ export function Route_get_total_amount(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Route_get_total_amount(this_arg);
+ return nativeResponseValue;
+ }
// struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
export function Route_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RouteHint_free(this_obj);
// debug statements here
}
- // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
- export function RouteHint_eq(a: number, b: number): boolean {
+ // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
+ export function RouteHint_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.RouteHint_eq(a, b);
+ const nativeResponseValue = wasm.RouteHint_clone(orig);
return nativeResponseValue;
}
- // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
- export function RouteHint_clone(orig: number): number {
+ // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
+ export function RouteHint_hash(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.RouteHint_clone(orig);
+ const nativeResponseValue = wasm.RouteHint_hash(o);
+ return nativeResponseValue;
+ }
+ // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
+ export function RouteHint_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHint_eq(a, b);
return nativeResponseValue;
}
// void RouteHintHop_free(struct LDKRouteHintHop this_obj);
const nativeResponseValue = wasm.RouteHintHop_new(encodeArray(src_node_id_arg), short_channel_id_arg, fees_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg);
return nativeResponseValue;
}
+ // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
+ export function RouteHintHop_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHintHop_clone(orig);
+ return nativeResponseValue;
+ }
+ // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
+ export function RouteHintHop_hash(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHintHop_hash(o);
+ return nativeResponseValue;
+ }
// bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
export function RouteHintHop_eq(a: number, b: number): boolean {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RouteHintHop_eq(a, b);
return nativeResponseValue;
}
- // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
- export function RouteHintHop_clone(orig: number): number {
+ // struct LDKCResult_RouteLightningErrorZ get_keysend_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey payee, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
+ export function get_keysend_route(our_node_id: Uint8Array, network: number, payee: Uint8Array, first_hops: number[], last_hops: number[], final_value_msat: number, final_cltv: number, logger: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.RouteHintHop_clone(orig);
+ const nativeResponseValue = wasm.get_keysend_route(encodeArray(our_node_id), network, encodeArray(payee), first_hops, last_hops, final_value_msat, final_cltv, logger);
return nativeResponseValue;
}
// struct LDKCResult_RouteLightningErrorZ get_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey payee, struct LDKInvoiceFeatures payee_features, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
const nativeResponseValue = wasm.NetworkGraph_clone(orig);
return nativeResponseValue;
}
- // void LockedNetworkGraph_free(struct LDKLockedNetworkGraph this_obj);
- export function LockedNetworkGraph_free(this_obj: number): void {
+ // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
+ export function ReadOnlyNetworkGraph_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.LockedNetworkGraph_free(this_obj);
+ const nativeResponseValue = wasm.ReadOnlyNetworkGraph_free(this_obj);
// debug statements here
}
- // void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_obj);
- export function NetGraphMsgHandler_free(this_obj: number): void {
+ // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
+ export function NetworkUpdate_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NetGraphMsgHandler_free(this_obj);
+ const nativeResponseValue = wasm.NetworkUpdate_free(this_ptr);
// debug statements here
}
- // MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKAccess *chain_access, struct LDKLogger logger);
- export function NetGraphMsgHandler_new(genesis_hash: Uint8Array, chain_access: number, logger: number): number {
+ // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
+ export function NetworkUpdate_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NetGraphMsgHandler_new(encodeArray(genesis_hash), chain_access, logger);
+ const nativeResponseValue = wasm.NetworkUpdate_clone(orig);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_from_net_graph(struct LDKAccess *chain_access, struct LDKLogger logger, struct LDKNetworkGraph network_graph);
- export function NetGraphMsgHandler_from_net_graph(chain_access: number, logger: number, network_graph: number): number {
+ // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
+ export function NetworkUpdate_channel_update_message(msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NetGraphMsgHandler_from_net_graph(chain_access, logger, network_graph);
+ const nativeResponseValue = wasm.NetworkUpdate_channel_update_message(msg);
return nativeResponseValue;
}
- // void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKAccess *chain_access);
- export function NetGraphMsgHandler_add_chain_access(this_arg: number, chain_access: number): void {
+ // struct LDKNetworkUpdate NetworkUpdate_channel_closed(uint64_t short_channel_id, bool is_permanent);
+ export function NetworkUpdate_channel_closed(short_channel_id: number, is_permanent: boolean): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NetGraphMsgHandler_add_chain_access(this_arg, chain_access);
+ const nativeResponseValue = wasm.NetworkUpdate_channel_closed(short_channel_id, is_permanent);
+ return nativeResponseValue;
+ }
+ // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
+ export function NetworkUpdate_node_failure(node_id: Uint8Array, is_permanent: boolean): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetworkUpdate_node_failure(encodeArray(node_id), is_permanent);
+ return nativeResponseValue;
+ }
+ // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
+ export function NetworkUpdate_write(obj: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetworkUpdate_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKEventHandler NetGraphMsgHandler_as_EventHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
+ export function NetGraphMsgHandler_as_EventHandler(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetGraphMsgHandler_as_EventHandler(this_arg);
+ return nativeResponseValue;
+ }
+ // void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_obj);
+ export function NetGraphMsgHandler_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetGraphMsgHandler_free(this_obj);
// debug statements here
}
- // MUST_USE_RES struct LDKLockedNetworkGraph NetGraphMsgHandler_read_locked_graph(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
- export function NetGraphMsgHandler_read_locked_graph(this_arg: number): number {
+ // struct LDKNetworkGraph NetGraphMsgHandler_get_network_graph(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_ptr);
+ export function NetGraphMsgHandler_get_network_graph(this_ptr: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NetGraphMsgHandler_read_locked_graph(this_arg);
+ const nativeResponseValue = wasm.NetGraphMsgHandler_get_network_graph(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKNetworkGraph LockedNetworkGraph_graph(const struct LDKLockedNetworkGraph *NONNULL_PTR this_arg);
- export function LockedNetworkGraph_graph(this_arg: number): number {
+ // void NetGraphMsgHandler_set_network_graph(struct LDKNetGraphMsgHandler *NONNULL_PTR this_ptr, struct LDKNetworkGraph val);
+ export function NetGraphMsgHandler_set_network_graph(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetGraphMsgHandler_set_network_graph(this_ptr, val);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_new(struct LDKNetworkGraph network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
+ export function NetGraphMsgHandler_new(network_graph: number, chain_access: number, logger: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.LockedNetworkGraph_graph(this_arg);
+ const nativeResponseValue = wasm.NetGraphMsgHandler_new(network_graph, chain_access, logger);
return nativeResponseValue;
}
+ // void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
+ export function NetGraphMsgHandler_add_chain_access(this_arg: number, chain_access: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetGraphMsgHandler_add_chain_access(this_arg, chain_access);
+ // debug statements here
+ }
// struct LDKRoutingMessageHandler NetGraphMsgHandler_as_RoutingMessageHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
export function NetGraphMsgHandler_as_RoutingMessageHandler(this_arg: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RoutingFees_clone(orig);
return nativeResponseValue;
}
+ // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
+ export function RoutingFees_hash(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RoutingFees_hash(o);
+ return nativeResponseValue;
+ }
// struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
export function RoutingFees_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.NetworkGraph_new(encodeArray(genesis_hash));
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
+ // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
+ export function NetworkGraph_read_only(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetworkGraph_read_only(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.NetworkGraph_update_node_from_announcement(this_arg, msg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_unsigned_announcement(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR msg);
+ // 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);
export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_announcement(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg, struct LDKAccess *chain_access);
+ // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg, struct LDKCOption_AccessZ chain_access);
export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_unsigned_announcement(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg, struct LDKAccess *chain_access);
+ // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_unsigned_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg, struct LDKCOption_AccessZ chain_access);
export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
return nativeResponseValue;
}
- // void NetworkGraph_close_channel_from_update(struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
+ // void NetworkGraph_close_channel_from_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
export function NetworkGraph_close_channel_from_update(this_arg: number, short_channel_id: number, is_permanent: boolean): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.NetworkGraph_close_channel_from_update(this_arg, short_channel_id, is_permanent);
// debug statements here
}
- // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
+ // void NetworkGraph_fail_node(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
+ export function NetworkGraph_fail_node(this_arg: number, _node_id: Uint8Array, is_permanent: boolean): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetworkGraph_fail_node(this_arg, encodeArray(_node_id), is_permanent);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.NetworkGraph_update_channel(this_arg, msg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
+ // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelManagerPersister_free(this_ptr);
// debug statements here
}
- // MUST_USE_RES struct LDKBackgroundProcessor BackgroundProcessor_start(struct LDKChannelManagerPersister persister, struct LDKEventHandler event_handler, const struct LDKChainMonitor *NONNULL_PTR chain_monitor, const struct LDKChannelManager *NONNULL_PTR channel_manager, const struct LDKPeerManager *NONNULL_PTR peer_manager, struct LDKLogger logger);
- export function BackgroundProcessor_start(persister: number, event_handler: number, chain_monitor: number, channel_manager: number, peer_manager: number, logger: number): number {
+ // MUST_USE_RES struct LDKBackgroundProcessor BackgroundProcessor_start(struct LDKChannelManagerPersister persister, struct LDKEventHandler event_handler, const struct LDKChainMonitor *NONNULL_PTR chain_monitor, const struct LDKChannelManager *NONNULL_PTR channel_manager, struct LDKNetGraphMsgHandler net_graph_msg_handler, const struct LDKPeerManager *NONNULL_PTR peer_manager, struct LDKLogger logger);
+ export function BackgroundProcessor_start(persister: number, event_handler: number, chain_monitor: number, channel_manager: number, net_graph_msg_handler: number, peer_manager: number, logger: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BackgroundProcessor_start(persister, event_handler, chain_monitor, channel_manager, net_graph_msg_handler, peer_manager, logger);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKCResult_NoneErrorZ BackgroundProcessor_join(struct LDKBackgroundProcessor this_arg);
+ export function BackgroundProcessor_join(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.BackgroundProcessor_start(persister, event_handler, chain_monitor, channel_manager, peer_manager, logger);
+ const nativeResponseValue = wasm.BackgroundProcessor_join(this_arg);
return nativeResponseValue;
}
// MUST_USE_RES struct LDKCResult_NoneErrorZ BackgroundProcessor_stop(struct LDKBackgroundProcessor this_arg);
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.RawDataPart_set_timestamp(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.RawDataPart_set_timestamp(this_ptr, val);
+ // debug statements here
+ }
+ // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
+ export function RawDataPart_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RawDataPart_eq(a, b);
+ return nativeResponseValue;
+ }
+ // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
+ export function RawDataPart_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RawDataPart_clone(orig);
+ return nativeResponseValue;
+ }
+ // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
+ export function PositiveTimestamp_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PositiveTimestamp_free(this_obj);
+ // debug statements here
+ }
+ // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
+ export function PositiveTimestamp_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PositiveTimestamp_eq(a, b);
+ return nativeResponseValue;
+ }
+ // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
+ export function PositiveTimestamp_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PositiveTimestamp_clone(orig);
+ return nativeResponseValue;
+ }
+ // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
+ export function SiPrefix_clone(orig: number): SiPrefix {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SiPrefix_clone(orig);
+ return nativeResponseValue;
+ }
+ // enum LDKSiPrefix SiPrefix_milli(void);
+ export function SiPrefix_milli(): SiPrefix {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SiPrefix_milli();
+ return nativeResponseValue;
+ }
+ // enum LDKSiPrefix SiPrefix_micro(void);
+ export function SiPrefix_micro(): SiPrefix {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SiPrefix_micro();
+ return nativeResponseValue;
+ }
+ // enum LDKSiPrefix SiPrefix_nano(void);
+ export function SiPrefix_nano(): SiPrefix {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SiPrefix_nano();
+ return nativeResponseValue;
+ }
+ // enum LDKSiPrefix SiPrefix_pico(void);
+ export function SiPrefix_pico(): SiPrefix {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SiPrefix_pico();
+ return nativeResponseValue;
}
- // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
- export function RawDataPart_eq(a: number, b: number): boolean {
+ // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
+ export function SiPrefix_eq(a: number, b: number): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.RawDataPart_eq(a, b);
+ const nativeResponseValue = wasm.SiPrefix_eq(a, b);
return nativeResponseValue;
}
- // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
- export function RawDataPart_clone(orig: number): number {
+ // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
+ export function SiPrefix_multiplier(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.RawDataPart_clone(orig);
+ const nativeResponseValue = wasm.SiPrefix_multiplier(this_arg);
return nativeResponseValue;
}
- // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
- export function PositiveTimestamp_free(this_obj: number): void {
+ // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
+ export function Currency_clone(orig: number): Currency {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.PositiveTimestamp_free(this_obj);
- // debug statements here
+ const nativeResponseValue = wasm.Currency_clone(orig);
+ return nativeResponseValue;
}
- // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
- export function PositiveTimestamp_eq(a: number, b: number): boolean {
+ // enum LDKCurrency Currency_bitcoin(void);
+ export function Currency_bitcoin(): Currency {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.PositiveTimestamp_eq(a, b);
+ const nativeResponseValue = wasm.Currency_bitcoin();
return nativeResponseValue;
}
- // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
- export function PositiveTimestamp_clone(orig: number): number {
+ // enum LDKCurrency Currency_bitcoin_testnet(void);
+ export function Currency_bitcoin_testnet(): Currency {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.PositiveTimestamp_clone(orig);
+ const nativeResponseValue = wasm.Currency_bitcoin_testnet();
return nativeResponseValue;
}
- // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
- export function SiPrefix_clone(orig: number): SiPrefix {
+ // enum LDKCurrency Currency_regtest(void);
+ export function Currency_regtest(): Currency {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.SiPrefix_clone(orig);
+ const nativeResponseValue = wasm.Currency_regtest();
return nativeResponseValue;
}
- // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
- export function SiPrefix_eq(a: number, b: number): boolean {
+ // enum LDKCurrency Currency_simnet(void);
+ export function Currency_simnet(): Currency {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.SiPrefix_eq(a, b);
+ const nativeResponseValue = wasm.Currency_simnet();
return nativeResponseValue;
}
- // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
- export function SiPrefix_multiplier(this_arg: number): number {
+ // enum LDKCurrency Currency_signet(void);
+ export function Currency_signet(): Currency {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.SiPrefix_multiplier(this_arg);
+ const nativeResponseValue = wasm.Currency_signet();
return nativeResponseValue;
}
- // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
- export function Currency_clone(orig: number): Currency {
+ // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
+ export function Currency_hash(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Currency_clone(orig);
+ const nativeResponseValue = wasm.Currency_hash(o);
return nativeResponseValue;
}
// bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
const nativeResponseValue = wasm.Sha256_free(this_obj);
// debug statements here
}
- // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
- export function Sha256_eq(a: number, b: number): boolean {
+ // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
+ export function Sha256_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Sha256_eq(a, b);
+ const nativeResponseValue = wasm.Sha256_clone(orig);
return nativeResponseValue;
}
- // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
- export function Sha256_clone(orig: number): number {
+ // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
+ export function Sha256_hash(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Sha256_clone(orig);
+ const nativeResponseValue = wasm.Sha256_hash(o);
+ return nativeResponseValue;
+ }
+ // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
+ export function Sha256_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Sha256_eq(a, b);
return nativeResponseValue;
}
// void Description_free(struct LDKDescription this_obj);
const nativeResponseValue = wasm.Description_free(this_obj);
// debug statements here
}
- // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
- export function Description_eq(a: number, b: number): boolean {
+ // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
+ export function Description_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Description_eq(a, b);
+ const nativeResponseValue = wasm.Description_clone(orig);
return nativeResponseValue;
}
- // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
- export function Description_clone(orig: number): number {
+ // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
+ export function Description_hash(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Description_clone(orig);
+ const nativeResponseValue = wasm.Description_hash(o);
+ return nativeResponseValue;
+ }
+ // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
+ export function Description_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Description_eq(a, b);
return nativeResponseValue;
}
// void PayeePubKey_free(struct LDKPayeePubKey this_obj);
const nativeResponseValue = wasm.PayeePubKey_free(this_obj);
// debug statements here
}
- // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
- export function PayeePubKey_eq(a: number, b: number): boolean {
+ // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
+ export function PayeePubKey_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.PayeePubKey_eq(a, b);
+ const nativeResponseValue = wasm.PayeePubKey_clone(orig);
return nativeResponseValue;
}
- // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
- export function PayeePubKey_clone(orig: number): number {
+ // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
+ export function PayeePubKey_hash(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.PayeePubKey_clone(orig);
+ const nativeResponseValue = wasm.PayeePubKey_hash(o);
+ return nativeResponseValue;
+ }
+ // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
+ export function PayeePubKey_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PayeePubKey_eq(a, b);
return nativeResponseValue;
}
// void ExpiryTime_free(struct LDKExpiryTime this_obj);
const nativeResponseValue = wasm.ExpiryTime_free(this_obj);
// debug statements here
}
- // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
- export function ExpiryTime_eq(a: number, b: number): boolean {
+ // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
+ export function ExpiryTime_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ExpiryTime_eq(a, b);
+ const nativeResponseValue = wasm.ExpiryTime_clone(orig);
return nativeResponseValue;
}
- // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
- export function ExpiryTime_clone(orig: number): number {
+ // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
+ export function ExpiryTime_hash(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ExpiryTime_clone(orig);
+ const nativeResponseValue = wasm.ExpiryTime_hash(o);
+ return nativeResponseValue;
+ }
+ // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
+ export function ExpiryTime_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ExpiryTime_eq(a, b);
return nativeResponseValue;
}
// void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
const nativeResponseValue = wasm.MinFinalCltvExpiry_free(this_obj);
// debug statements here
}
- // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
- export function MinFinalCltvExpiry_eq(a: number, b: number): boolean {
+ // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
+ export function MinFinalCltvExpiry_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.MinFinalCltvExpiry_eq(a, b);
+ const nativeResponseValue = wasm.MinFinalCltvExpiry_clone(orig);
return nativeResponseValue;
}
- // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
- export function MinFinalCltvExpiry_clone(orig: number): number {
+ // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
+ export function MinFinalCltvExpiry_hash(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.MinFinalCltvExpiry_clone(orig);
+ const nativeResponseValue = wasm.MinFinalCltvExpiry_hash(o);
+ return nativeResponseValue;
+ }
+ // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
+ export function MinFinalCltvExpiry_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.MinFinalCltvExpiry_eq(a, b);
return nativeResponseValue;
}
// void Fallback_free(struct LDKFallback this_ptr);
const nativeResponseValue = wasm.Fallback_clone(orig);
return nativeResponseValue;
}
+ // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
+ export function Fallback_seg_wit_program(version: number, program: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Fallback_seg_wit_program(version, encodeArray(program));
+ return nativeResponseValue;
+ }
+ // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
+ export function Fallback_pub_key_hash(a: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Fallback_pub_key_hash(encodeArray(a));
+ return nativeResponseValue;
+ }
+ // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
+ export function Fallback_script_hash(a: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Fallback_script_hash(encodeArray(a));
+ return nativeResponseValue;
+ }
+ // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
+ export function Fallback_hash(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Fallback_hash(o);
+ return nativeResponseValue;
+ }
// bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
export function Fallback_eq(a: number, b: number): boolean {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.InvoiceSignature_free(this_obj);
// debug statements here
}
- // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
- export function InvoiceSignature_eq(a: number, b: number): boolean {
+ // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
+ export function InvoiceSignature_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InvoiceSignature_eq(a, b);
+ const nativeResponseValue = wasm.InvoiceSignature_clone(orig);
return nativeResponseValue;
}
- // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
- export function InvoiceSignature_clone(orig: number): number {
+ // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
+ export function InvoiceSignature_eq(a: number, b: number): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InvoiceSignature_clone(orig);
+ const nativeResponseValue = wasm.InvoiceSignature_eq(a, b);
return nativeResponseValue;
}
// void PrivateRoute_free(struct LDKPrivateRoute this_obj);
const nativeResponseValue = wasm.PrivateRoute_free(this_obj);
// debug statements here
}
- // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
- export function PrivateRoute_eq(a: number, b: number): boolean {
+ // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
+ export function PrivateRoute_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.PrivateRoute_eq(a, b);
+ const nativeResponseValue = wasm.PrivateRoute_clone(orig);
return nativeResponseValue;
}
- // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
- export function PrivateRoute_clone(orig: number): number {
+ // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
+ export function PrivateRoute_hash(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.PrivateRoute_clone(orig);
+ const nativeResponseValue = wasm.PrivateRoute_hash(o);
+ return nativeResponseValue;
+ }
+ // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
+ export function PrivateRoute_eq(a: number, b: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.PrivateRoute_eq(a, b);
return nativeResponseValue;
}
// MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
const nativeResponseValue = wasm.CreationError_clone(orig);
return nativeResponseValue;
}
+ // enum LDKCreationError CreationError_description_too_long(void);
+ export function CreationError_description_too_long(): CreationError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CreationError_description_too_long();
+ return nativeResponseValue;
+ }
+ // enum LDKCreationError CreationError_route_too_long(void);
+ export function CreationError_route_too_long(): CreationError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CreationError_route_too_long();
+ return nativeResponseValue;
+ }
+ // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
+ export function CreationError_timestamp_out_of_bounds(): CreationError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CreationError_timestamp_out_of_bounds();
+ return nativeResponseValue;
+ }
+ // enum LDKCreationError CreationError_expiry_time_out_of_bounds(void);
+ export function CreationError_expiry_time_out_of_bounds(): CreationError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CreationError_expiry_time_out_of_bounds();
+ return nativeResponseValue;
+ }
// bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
export function CreationError_eq(a: number, b: number): boolean {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.SemanticError_clone(orig);
return nativeResponseValue;
}
+ // enum LDKSemanticError SemanticError_no_payment_hash(void);
+ export function SemanticError_no_payment_hash(): SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SemanticError_no_payment_hash();
+ return nativeResponseValue;
+ }
+ // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
+ export function SemanticError_multiple_payment_hashes(): SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SemanticError_multiple_payment_hashes();
+ return nativeResponseValue;
+ }
+ // enum LDKSemanticError SemanticError_no_description(void);
+ export function SemanticError_no_description(): SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SemanticError_no_description();
+ return nativeResponseValue;
+ }
+ // enum LDKSemanticError SemanticError_multiple_descriptions(void);
+ export function SemanticError_multiple_descriptions(): SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SemanticError_multiple_descriptions();
+ return nativeResponseValue;
+ }
+ // enum LDKSemanticError SemanticError_no_payment_secret(void);
+ export function SemanticError_no_payment_secret(): SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SemanticError_no_payment_secret();
+ return nativeResponseValue;
+ }
+ // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
+ export function SemanticError_multiple_payment_secrets(): SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SemanticError_multiple_payment_secrets();
+ return nativeResponseValue;
+ }
+ // enum LDKSemanticError SemanticError_invalid_features(void);
+ export function SemanticError_invalid_features(): SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SemanticError_invalid_features();
+ return nativeResponseValue;
+ }
+ // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
+ export function SemanticError_invalid_recovery_id(): SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SemanticError_invalid_recovery_id();
+ return nativeResponseValue;
+ }
+ // enum LDKSemanticError SemanticError_invalid_signature(void);
+ export function SemanticError_invalid_signature(): SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SemanticError_invalid_signature();
+ return nativeResponseValue;
+ }
+ // enum LDKSemanticError SemanticError_imprecise_amount(void);
+ export function SemanticError_imprecise_amount(): SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SemanticError_imprecise_amount();
+ return nativeResponseValue;
+ }
// bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
export function SemanticError_eq(a: number, b: number): boolean {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.SignOrCreationError_clone(orig);
return nativeResponseValue;
}
+ // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
+ export function SignOrCreationError_sign_error(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SignOrCreationError_sign_error();
+ return nativeResponseValue;
+ }
+ // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
+ export function SignOrCreationError_creation_error(a: CreationError): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.SignOrCreationError_creation_error(a);
+ return nativeResponseValue;
+ }
// bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
export function SignOrCreationError_eq(a: number, b: number): boolean {
if(!isWasmInitialized) {
projects / ldk-java / blobdiff