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_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);
- public static native boolean LDKCResult_InitFeaturesDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelConfigDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ChannelConfigDecodeErrorZ_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 class LDKErrorAction {
private LDKErrorAction() {}
export class DisconnectPeer extends LDKErrorAction {
static { LDKMessageSendEvent.init(); }
public static native LDKMessageSendEvent LDKMessageSendEvent_ref_from_ptr(long ptr);
public static native long LDKCVec_MessageSendEventZ_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);
+ 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 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);
+ public static native boolean LDKCResult_InitFeaturesDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ChannelConfigDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_err(long arg);
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_NoneChannelMonitorUpdateErrZ_result_ok(long arg);
public static native void LDKCResult_NoneChannelMonitorUpdateErrZ_get_ok(long arg);
public static native LDKChannelMonitorUpdateErr LDKCResult_NoneChannelMonitorUpdateErrZ_get_err(long arg);
+ public static class LDKMonitorEvent {
+ private LDKMonitorEvent() {}
+ export class HTLCEvent extends LDKMonitorEvent {
+ HTLCEvent() { }
+ }
+ export class CommitmentTxBroadcasted extends LDKMonitorEvent {
+ CommitmentTxBroadcasted() { }
+ }
+ static native void init();
+ }
+ static { LDKMonitorEvent.init(); }
+ public static native LDKMonitorEvent LDKMonitorEvent_ref_from_ptr(long ptr);
public static native long LDKCVec_MonitorEventZ_new(number[] elems);
- public static native long LDKC2Tuple_u64u64Z_new(number a, number b);
- public static native number LDKC2Tuple_u64u64Z_get_a(long ptr);
- public static native number LDKC2Tuple_u64u64Z_get_b(long ptr);
public static class LDKSpendableOutputDescriptor {
private LDKSpendableOutputDescriptor() {}
export class StaticOutput extends LDKSpendableOutputDescriptor {
public number output;
StaticOutput(number outpoint, number output) { this.outpoint = outpoint; this.output = output; }
}
- export class DynamicOutputP2WSH extends LDKSpendableOutputDescriptor {
- public number outpoint;
- public Uint8Array per_commitment_point;
- public number to_self_delay;
- public number output;
- public number key_derivation_params;
- public Uint8Array revocation_pubkey;
- DynamicOutputP2WSH(number outpoint, Uint8Array per_commitment_point, number to_self_delay, number output, number key_derivation_params, Uint8Array revocation_pubkey) { this.outpoint = outpoint; this.per_commitment_point = per_commitment_point; this.to_self_delay = to_self_delay; this.output = output; this.key_derivation_params = key_derivation_params; this.revocation_pubkey = revocation_pubkey; }
+ export class DelayedPaymentOutput extends LDKSpendableOutputDescriptor {
+ DelayedPaymentOutput() { }
}
- export class StaticOutputCounterpartyPayment extends LDKSpendableOutputDescriptor {
- public number outpoint;
- public number output;
- public number key_derivation_params;
- StaticOutputCounterpartyPayment(number outpoint, number output, number key_derivation_params) { this.outpoint = outpoint; this.output = output; this.key_derivation_params = key_derivation_params; }
+ export class StaticPaymentOutput extends LDKSpendableOutputDescriptor {
+ StaticPaymentOutput() { }
}
static native void init();
}
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
- export interface LDKChannelKeys {
+ export interface LDKSign {
get_per_commitment_point (idx: number): Uint8Array;
release_commitment_secret (idx: number): Uint8Array;
- key_derivation_params (): number;
+ channel_keys_id (): Uint8Array;
sign_counterparty_commitment (commitment_tx: number): number;
sign_holder_commitment_and_htlcs (commitment_tx: number): number;
sign_justice_transaction (justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: number): number;
write (): Uint8Array;
}
- export function LDKChannelKeys_new(impl: LDKChannelKeys, pubkeys: number): number {
+ export function LDKSign_new(impl: LDKSign, pubkeys: number): number {
throw new Error('unimplemented'); // TODO: bind to WASM
}
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // LDKPublicKey ChannelKeys_get_per_commitment_point LDKChannelKeys* this_arg, uint64_t idx
- export function ChannelKeys_get_per_commitment_point(this_arg: number, idx: number): Uint8Array {
+ // LDKPublicKey Sign_get_per_commitment_point LDKSign* this_arg, uint64_t idx
+ export function Sign_get_per_commitment_point(this_arg: number, idx: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_get_per_commitment_point(this_arg, idx);
+ const nativeResponseValue = wasm.Sign_get_per_commitment_point(this_arg, idx);
return decodeArray(nativeResponseValue);
}
- // LDKThirtyTwoBytes ChannelKeys_release_commitment_secret LDKChannelKeys* this_arg, uint64_t idx
- export function ChannelKeys_release_commitment_secret(this_arg: number, idx: number): Uint8Array {
+ // LDKThirtyTwoBytes Sign_release_commitment_secret LDKSign* this_arg, uint64_t idx
+ export function Sign_release_commitment_secret(this_arg: number, idx: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_release_commitment_secret(this_arg, idx);
+ const nativeResponseValue = wasm.Sign_release_commitment_secret(this_arg, idx);
return decodeArray(nativeResponseValue);
}
- // LDKC2Tuple_u64u64Z ChannelKeys_key_derivation_params LDKChannelKeys* this_arg
- export function ChannelKeys_key_derivation_params(this_arg: number): number {
+ // LDKThirtyTwoBytes Sign_channel_keys_id LDKSign* this_arg
+ export function Sign_channel_keys_id(this_arg: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_key_derivation_params(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.Sign_channel_keys_id(this_arg);
+ return decodeArray(nativeResponseValue);
}
- // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ChannelKeys_sign_counterparty_commitment LDKChannelKeys* this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx
- export function ChannelKeys_sign_counterparty_commitment(this_arg: number, commitment_tx: number): number {
+ // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ Sign_sign_counterparty_commitment LDKSign* this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx
+ export function Sign_sign_counterparty_commitment(this_arg: number, commitment_tx: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_sign_counterparty_commitment(this_arg, commitment_tx);
+ const nativeResponseValue = wasm.Sign_sign_counterparty_commitment(this_arg, commitment_tx);
return nativeResponseValue;
}
- // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ChannelKeys_sign_holder_commitment_and_htlcs LDKChannelKeys* this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
- export function ChannelKeys_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
+ // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ Sign_sign_holder_commitment_and_htlcs LDKSign* this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
+ export function Sign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
+ const nativeResponseValue = wasm.Sign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
return nativeResponseValue;
}
- // LDKCResult_SignatureNoneZ ChannelKeys_sign_justice_transaction LDKChannelKeys* this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
- export function ChannelKeys_sign_justice_transaction(this_arg: number, justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: number): number {
+ // LDKCResult_SignatureNoneZ Sign_sign_justice_transaction LDKSign* this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
+ export function Sign_sign_justice_transaction(this_arg: number, justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_sign_justice_transaction(this_arg, encodeArray(justice_tx), input, amount, encodeArray(per_commitment_key), htlc);
+ const nativeResponseValue = wasm.Sign_sign_justice_transaction(this_arg, encodeArray(justice_tx), input, amount, encodeArray(per_commitment_key), htlc);
return nativeResponseValue;
}
- // LDKCResult_SignatureNoneZ ChannelKeys_sign_counterparty_htlc_transaction LDKChannelKeys* this_arg, struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
- export function ChannelKeys_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: Uint8Array, input: number, amount: number, per_commitment_point: Uint8Array, htlc: number): number {
+ // LDKCResult_SignatureNoneZ Sign_sign_counterparty_htlc_transaction LDKSign* this_arg, struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
+ export function Sign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: Uint8Array, input: number, amount: number, per_commitment_point: Uint8Array, htlc: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_sign_counterparty_htlc_transaction(this_arg, encodeArray(htlc_tx), input, amount, encodeArray(per_commitment_point), htlc);
+ const nativeResponseValue = wasm.Sign_sign_counterparty_htlc_transaction(this_arg, encodeArray(htlc_tx), input, amount, encodeArray(per_commitment_point), htlc);
return nativeResponseValue;
}
- // LDKCResult_SignatureNoneZ ChannelKeys_sign_closing_transaction LDKChannelKeys* this_arg, struct LDKTransaction closing_tx
- export function ChannelKeys_sign_closing_transaction(this_arg: number, closing_tx: Uint8Array): number {
+ // LDKCResult_SignatureNoneZ Sign_sign_closing_transaction LDKSign* this_arg, struct LDKTransaction closing_tx
+ export function Sign_sign_closing_transaction(this_arg: number, closing_tx: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_sign_closing_transaction(this_arg, encodeArray(closing_tx));
+ const nativeResponseValue = wasm.Sign_sign_closing_transaction(this_arg, encodeArray(closing_tx));
return nativeResponseValue;
}
- // LDKCResult_SignatureNoneZ ChannelKeys_sign_channel_announcement LDKChannelKeys* this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
- export function ChannelKeys_sign_channel_announcement(this_arg: number, msg: number): number {
+ // LDKCResult_SignatureNoneZ Sign_sign_channel_announcement LDKSign* this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
+ export function Sign_sign_channel_announcement(this_arg: number, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_sign_channel_announcement(this_arg, msg);
+ const nativeResponseValue = wasm.Sign_sign_channel_announcement(this_arg, msg);
return nativeResponseValue;
}
- // void ChannelKeys_ready_channel LDKChannelKeys* this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
- export function ChannelKeys_ready_channel(this_arg: number, channel_parameters: number): void {
+ // void Sign_ready_channel LDKSign* this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
+ export function Sign_ready_channel(this_arg: number, channel_parameters: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_ready_channel(this_arg, channel_parameters);
+ const nativeResponseValue = wasm.Sign_ready_channel(this_arg, channel_parameters);
// debug statements here
}
- // LDKCVec_u8Z ChannelKeys_write LDKChannelKeys* this_arg
- export function ChannelKeys_write(this_arg: number): Uint8Array {
+ // LDKCVec_u8Z Sign_write LDKSign* this_arg
+ export function Sign_write(this_arg: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_write(this_arg);
+ const nativeResponseValue = wasm.Sign_write(this_arg);
return decodeArray(nativeResponseValue);
}
- // LDKChannelPublicKeys ChannelKeys_get_pubkeys LDKChannelKeys* this_arg
- export function ChannelKeys_get_pubkeys(this_arg: number): number {
+ // LDKChannelPublicKeys Sign_get_pubkeys LDKSign* this_arg
+ export function Sign_get_pubkeys(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_get_pubkeys(this_arg);
+ const nativeResponseValue = wasm.Sign_get_pubkeys(this_arg);
return nativeResponseValue;
}
public static native long LDKC2Tuple_BlockHashChannelMonitorZ_new(Uint8Array a, number b);
public static native boolean LDKCResult_NoneAPIErrorZ_result_ok(long arg);
public static native void LDKCResult_NoneAPIErrorZ_get_ok(long arg);
public static native number LDKCResult_NoneAPIErrorZ_get_err(long arg);
+ public static native long LDKCVec_CResult_NoneAPIErrorZZ_new(number[] elems);
+ public static native long LDKCVec_APIErrorZ_new(number[] elems);
public static native long LDKCVec_ChannelDetailsZ_new(number[] elems);
+ public static class LDKPaymentSendFailure {
+ private LDKPaymentSendFailure() {}
+ export class ParameterError extends LDKPaymentSendFailure {
+ ParameterError() { }
+ }
+ export class PathParameterError extends LDKPaymentSendFailure {
+ PathParameterError() { }
+ }
+ export class AllFailedRetrySafe extends LDKPaymentSendFailure {
+ AllFailedRetrySafe() { }
+ }
+ export class PartialFailure extends LDKPaymentSendFailure {
+ PartialFailure() { }
+ }
+ static native void init();
+ }
+ static { LDKPaymentSendFailure.init(); }
+ public static native LDKPaymentSendFailure LDKPaymentSendFailure_ref_from_ptr(long ptr);
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);
const nativeResponseValue = wasm.BroadcasterInterface_broadcast_transaction(this_arg, encodeArray(tx));
// debug statements here
}
- public static native boolean LDKCResult_ChannelKeysDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ChannelKeysDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ChannelKeysDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_SignDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_SignDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_SignDecodeErrorZ_get_err(long arg);
get_node_secret (): Uint8Array;
get_destination_script (): Uint8Array;
get_shutdown_pubkey (): Uint8Array;
- get_channel_keys (inbound: boolean, channel_value_satoshis: number): 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_shutdown_pubkey(this_arg);
return decodeArray(nativeResponseValue);
}
- // LDKChannelKeys KeysInterface_get_channel_keys LDKKeysInterface* this_arg, bool inbound, uint64_t channel_value_satoshis
- export function KeysInterface_get_channel_keys(this_arg: number, inbound: boolean, channel_value_satoshis: number): number {
+ // LDKSign KeysInterface_get_channel_signer LDKKeysInterface* 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 {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.KeysInterface_get_channel_keys(this_arg, inbound, channel_value_satoshis);
+ const nativeResponseValue = wasm.KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
return nativeResponseValue;
}
// LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface* this_arg
const nativeResponseValue = wasm.KeysInterface_get_secure_random_bytes(this_arg);
return decodeArray(nativeResponseValue);
}
- // LDKCResult_ChannelKeysDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface* this_arg, struct LDKu8slice reader
+ // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface* this_arg, struct LDKu8slice reader
export function KeysInterface_read_chan_signer(this_arg: number, reader: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
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_InMemoryChannelKeysDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_InMemoryChannelKeysDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_InMemoryChannelKeysDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_CVec_CVec_u8ZZNoneZ_result_ok(long arg);
+ public static native Uint8Array[] LDKCResult_CVec_CVec_u8ZZNoneZ_get_ok(long arg);
+ public static native void LDKCResult_CVec_CVec_u8ZZNoneZ_get_err(long arg);
+ public static native boolean LDKCResult_InMemorySignerDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_InMemorySignerDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_InMemorySignerDecodeErrorZ_get_err(long arg);
+ public static native long LDKCVec_TxOutZ_new(number[] elems);
+ public static native boolean LDKCResult_TransactionNoneZ_result_ok(long arg);
+ public static native Uint8Array LDKCResult_TransactionNoneZ_get_ok(long arg);
+ public static native void LDKCResult_TransactionNoneZ_get_err(long arg);
public static native long LDKCVec_RouteHopZ_new(number[] elems);
public static native boolean LDKCResult_RouteDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_RouteDecodeErrorZ_get_ok(long arg);
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
+
+ export interface LDKListen {
+ block_connected (block: Uint8Array, height: number): void;
+ block_disconnected (header: Uint8Array, height: number): void;
+ }
+
+ export function LDKListen_new(impl: LDKListen): number {
+ throw new Error('unimplemented'); // TODO: bind to WASM
+ }
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
+
+
+ // void Listen_block_connected LDKListen* this_arg, struct LDKu8slice block, uint32_t height
+ export function Listen_block_connected(this_arg: number, block: Uint8Array, height: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Listen_block_connected(this_arg, encodeArray(block), height);
+ // debug statements here
+ }
+ // void Listen_block_disconnected LDKListen* this_arg, const uint8_t (*header)[80], uint32_t height
+ export function Listen_block_disconnected(this_arg: number, header: Uint8Array, height: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Listen_block_disconnected(this_arg, encodeArray(header), height);
+ // debug statements here
+ }
+
+
+
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
export interface LDKFilter {
handle_funding_created (their_node_id: Uint8Array, msg: number): void;
handle_funding_signed (their_node_id: Uint8Array, msg: number): void;
handle_funding_locked (their_node_id: Uint8Array, msg: number): void;
- handle_shutdown (their_node_id: Uint8Array, msg: number): void;
+ handle_shutdown (their_node_id: Uint8Array, their_features: number, msg: number): void;
handle_closing_signed (their_node_id: Uint8Array, msg: number): void;
handle_update_add_htlc (their_node_id: Uint8Array, msg: number): void;
handle_update_fulfill_htlc (their_node_id: Uint8Array, msg: number): void;
const nativeResponseValue = wasm.ChannelMessageHandler_handle_funding_locked(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg
- export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: Uint8Array, msg: number): void {
+ // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKInitFeatures *NONNULL_PTR their_features, const struct LDKShutdown *NONNULL_PTR msg
+ export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: Uint8Array, their_features: number, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMessageHandler_handle_shutdown(this_arg, encodeArray(their_node_id), msg);
+ const nativeResponseValue = wasm.ChannelMessageHandler_handle_shutdown(this_arg, encodeArray(their_node_id), their_features, msg);
// debug statements here
}
// void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_clone(orig);
return nativeResponseValue;
}
+ // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
+ export function CVec_MessageSendEventZ_free(_res: number[]): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CVec_MessageSendEventZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
+ export function CResult_boolLightningErrorZ_ok(o: boolean): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_boolLightningErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
+ export function CResult_boolLightningErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_boolLightningErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
+ export function CResult_boolLightningErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_boolLightningErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
+ export function CResult_boolLightningErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_boolLightningErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
+ export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
+ export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
+ return nativeResponseValue;
+ }
+ // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
+ export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
+ // debug statements here
+ }
+ // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
+ export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number[]): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
+ // debug statements here
+ }
+ // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
+ export function CVec_NodeAnnouncementZ_free(_res: number[]): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CVec_NodeAnnouncementZ_free(_res);
+ // debug statements here
+ }
+ // 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;
+ }
// void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
export function CVec_PublicKeyZ_free(_res: Uint8Array[]): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
- export function CResult_boolLightningErrorZ_ok(o: boolean): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_boolLightningErrorZ_ok(o);
- return nativeResponseValue;
- }
- // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
- export function CResult_boolLightningErrorZ_err(e: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_boolLightningErrorZ_err(e);
- return nativeResponseValue;
- }
- // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
- export function CResult_boolLightningErrorZ_free(_res: number): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_boolLightningErrorZ_free(_res);
- // debug statements here
- }
- // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
- export function CResult_boolLightningErrorZ_clone(orig: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_boolLightningErrorZ_clone(orig);
- return nativeResponseValue;
- }
- // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
- export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
- return nativeResponseValue;
- }
- // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
- export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
- return nativeResponseValue;
- }
- // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
- export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
- // debug statements here
- }
- // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
- export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number[]): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
- // debug statements here
- }
- // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
- export function CVec_NodeAnnouncementZ_free(_res: number[]): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CVec_NodeAnnouncementZ_free(_res);
- // debug statements here
- }
- // 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;
- }
- // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
- export function CVec_MessageSendEventZ_free(_res: number[]): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CVec_MessageSendEventZ_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_ChannelInfoDecodeErrorZ_free(_res);
// debug statements here
}
+ // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
// struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_free(_res);
// debug statements here
}
+ // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_NetworkGraphDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
// struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
export function C2Tuple_usizeTransactionZ_new(a: number, b: Uint8Array): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_clone(orig);
return nativeResponseValue;
}
+ // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
+ export function CVec_CResult_NoneAPIErrorZZ_free(_res: number[]): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CVec_CResult_NoneAPIErrorZZ_free(_res);
+ // debug statements here
+ }
+ // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
+ export function CVec_APIErrorZ_free(_res: number[]): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CVec_APIErrorZ_free(_res);
+ // debug statements here
+ }
// void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
export function CVec_ChannelDetailsZ_free(_res: number[]): void {
if(!isWasmInitialized) {
return nativeResponseValue;
}
// void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
- export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.C2Tuple_BlockHashChannelManagerZ_free(_res);
- // debug statements here
- }
- // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
- export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
- return nativeResponseValue;
- }
- // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
- return nativeResponseValue;
- }
- // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
- export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
+ export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelManagerZ_free(_res);
// debug statements here
}
- // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
- export function C2Tuple_u64u64Z_clone(orig: number): number {
+ // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
+ export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_u64u64Z_clone(orig);
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
- export function C2Tuple_u64u64Z_new(a: number, b: number): number {
+ // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_u64u64Z_new(a, b);
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
- export function C2Tuple_u64u64Z_free(_res: number): void {
+ // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
+ export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_u64u64Z_free(_res);
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
// debug statements here
}
// struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
const nativeResponseValue = wasm.CResult_SignatureNoneZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelKeysDecodeErrorZ CResult_ChannelKeysDecodeErrorZ_ok(struct LDKChannelKeys o);
- export function CResult_ChannelKeysDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
+ export function CResult_SignDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_SignDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
+ export function CResult_SignDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_SignDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
+ export function CVec_CVec_u8ZZ_free(_res: Uint8Array[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelKeysDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CVec_CVec_u8ZZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
+ export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: Uint8Array[]): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelKeysDecodeErrorZ CResult_ChannelKeysDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ChannelKeysDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
+ export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelKeysDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_err();
return nativeResponseValue;
}
- // void CResult_ChannelKeysDecodeErrorZ_free(struct LDKCResult_ChannelKeysDecodeErrorZ _res);
- export function CResult_ChannelKeysDecodeErrorZ_free(_res: number): void {
+ // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
+ export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelKeysDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ChannelKeysDecodeErrorZ CResult_ChannelKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelKeysDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ChannelKeysDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
+ export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
+ export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelKeysDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_InMemoryChannelKeysDecodeErrorZ CResult_InMemoryChannelKeysDecodeErrorZ_ok(struct LDKInMemoryChannelKeys o);
- export function CResult_InMemoryChannelKeysDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InMemoryChannelKeysDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // struct LDKCResult_InMemoryChannelKeysDecodeErrorZ CResult_InMemoryChannelKeysDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_InMemoryChannelKeysDecodeErrorZ_err(e: number): number {
+ // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
+ export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InMemoryChannelKeysDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // void CResult_InMemoryChannelKeysDecodeErrorZ_free(struct LDKCResult_InMemoryChannelKeysDecodeErrorZ _res);
- export function CResult_InMemoryChannelKeysDecodeErrorZ_free(_res: number): void {
+ // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
+ export function CVec_TxOutZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InMemoryChannelKeysDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CVec_TxOutZ_free(_res);
// debug statements here
}
- // struct LDKCResult_InMemoryChannelKeysDecodeErrorZ CResult_InMemoryChannelKeysDecodeErrorZ_clone(const struct LDKCResult_InMemoryChannelKeysDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_InMemoryChannelKeysDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
+ export function CResult_TransactionNoneZ_ok(o: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TransactionNoneZ_ok(encodeArray(o));
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
+ export function CResult_TransactionNoneZ_err(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InMemoryChannelKeysDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_TransactionNoneZ_err();
return nativeResponseValue;
}
+ // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
+ export function CResult_TransactionNoneZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TransactionNoneZ_free(_res);
+ // debug statements here
+ }
// void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
export function CVec_RouteHopZ_free(_res: number[]): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Access_free(this_ptr);
// debug statements here
}
+ // void Listen_free(struct LDKListen this_ptr);
+ export function Listen_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Listen_free(this_ptr);
+ // debug statements here
+ }
// void Watch_free(struct LDKWatch this_ptr);
export function Watch_free(this_ptr: number): void {
if(!isWasmInitialized) {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.HTLCUpdate_clone(orig);
+ const nativeResponseValue = wasm.HTLCUpdate_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
+ export function HTLCUpdate_write(obj: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.HTLCUpdate_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
+ export function HTLCUpdate_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.HTLCUpdate_read(encodeArray(ser));
+ return nativeResponseValue;
+ }
+ // void ChannelMonitor_free(struct LDKChannelMonitor this_ptr);
+ export function ChannelMonitor_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_free(this_ptr);
+ // debug statements here
+ }
+ // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
+ export function ChannelMonitor_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
+ export function ChannelMonitor_write(obj: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
+ // MUST_USE_RES struct LDKCResult_NoneMonitorUpdateErrorZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
+ export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
+ export function ChannelMonitor_get_latest_update_id(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_get_latest_update_id(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
+ export function ChannelMonitor_get_funding_txo(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_get_funding_txo(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
+ export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
+ export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_get_and_clear_pending_events(this_arg);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKCVec_TransactionZ ChannelMonitor_get_latest_holder_commitment_txn(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger);
+ export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): Uint8Array[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
+ export function ChannelMonitor_block_connected(this_arg: number, header: Uint8Array, txdata: number[], height: number, broadcaster: number, fee_estimator: number, logger: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_block_connected(this_arg, encodeArray(header), txdata, height, broadcaster, fee_estimator, logger);
+ return nativeResponseValue;
+ }
+ // void ChannelMonitor_block_disconnected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
+ export function ChannelMonitor_block_disconnected(this_arg: number, header: Uint8Array, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_block_disconnected(this_arg, encodeArray(header), height, broadcaster, fee_estimator, logger);
+ // debug statements here
+ }
+ // void Persist_free(struct LDKPersist this_ptr);
+ export function Persist_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Persist_free(this_ptr);
+ // debug statements here
+ }
+ // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
+ export function C2Tuple_BlockHashChannelMonitorZ_read(ser: Uint8Array, arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_read(encodeArray(ser), arg);
+ return nativeResponseValue;
+ }
+ // void OutPoint_free(struct LDKOutPoint this_ptr);
+ export function OutPoint_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OutPoint_free(this_ptr);
+ // debug statements here
+ }
+ // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
+ export function OutPoint_get_txid(this_ptr: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OutPoint_get_txid(this_ptr);
+ return decodeArray(nativeResponseValue);
+ }
+ // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+ export function OutPoint_set_txid(this_ptr: number, val: Uint8Array): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OutPoint_set_txid(this_ptr, encodeArray(val));
+ // debug statements here
+ }
+ // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
+ export function OutPoint_get_index(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OutPoint_get_index(this_ptr);
+ return nativeResponseValue;
+ }
+ // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
+ export function OutPoint_set_index(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OutPoint_set_index(this_ptr, val);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
+ export function OutPoint_new(txid_arg: Uint8Array, index_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OutPoint_new(encodeArray(txid_arg), index_arg);
+ return nativeResponseValue;
+ }
+ // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
+ export function OutPoint_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OutPoint_clone(orig);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
+ export function OutPoint_to_channel_id(this_arg: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OutPoint_to_channel_id(this_arg);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
+ export function OutPoint_write(obj: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OutPoint_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
+ // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
+ export function OutPoint_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.OutPoint_read(encodeArray(ser));
return nativeResponseValue;
}
- // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
- export function HTLCUpdate_write(obj: number): Uint8Array {
+ // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_ptr);
+ export function DelayedPaymentOutputDescriptor_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.HTLCUpdate_write(obj);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_free(this_ptr);
+ // debug statements here
}
- // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
- export function HTLCUpdate_read(ser: Uint8Array): number {
+ // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
+ export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.HTLCUpdate_read(encodeArray(ser));
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
return nativeResponseValue;
}
- // void ChannelMonitor_free(struct LDKChannelMonitor this_ptr);
- export function ChannelMonitor_free(this_ptr: number): void {
+ // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
+ export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_free(this_ptr);
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
// debug statements here
}
- // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
- export function ChannelMonitor_clone(orig: number): number {
+ // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
+ export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
+ return decodeArray(nativeResponseValue);
}
- // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
- export function ChannelMonitor_write(obj: number): Uint8Array {
+ // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+ export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_write(obj);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, encodeArray(val));
+ // debug statements here
}
- // MUST_USE_RES struct LDKCResult_NoneMonitorUpdateErrorZ ChannelMonitor_update_monitor(struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
- export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
+ // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
+ export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
- export function ChannelMonitor_get_latest_update_id(this_arg: number): number {
+ // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
+ export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_get_latest_update_id(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
- export function ChannelMonitor_get_funding_txo(this_arg: number): number {
+ // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
+ export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_get_funding_txo(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(struct LDKChannelMonitor *NONNULL_PTR this_arg);
- export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number[] {
+ // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
+ export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
+ return decodeArray(nativeResponseValue);
}
- // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(struct LDKChannelMonitor *NONNULL_PTR this_arg);
- export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number[] {
+ // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+ export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_get_and_clear_pending_events(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, encodeArray(val));
+ // debug statements here
}
- // MUST_USE_RES struct LDKCVec_TransactionZ ChannelMonitor_get_latest_holder_commitment_txn(struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger);
- export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): Uint8Array[] {
+ // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
+ export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
+ return decodeArray(nativeResponseValue);
}
- // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
- export function ChannelMonitor_block_connected(this_arg: number, header: Uint8Array, txdata: number[], height: number, broadcaster: number, fee_estimator: number, logger: number): number[] {
+ // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+ export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_block_connected(this_arg, encodeArray(header), txdata, height, broadcaster, fee_estimator, logger);
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, encodeArray(val));
+ // debug statements here
+ }
+ // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
+ export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
return nativeResponseValue;
}
- // void ChannelMonitor_block_disconnected(struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
- export function ChannelMonitor_block_disconnected(this_arg: number, header: Uint8Array, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
+ // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
+ export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_block_disconnected(this_arg, encodeArray(header), height, broadcaster, fee_estimator, logger);
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
// debug statements here
}
- // void Persist_free(struct LDKPersist this_ptr);
- export function Persist_free(this_ptr: number): void {
+ // MUST_USE_RES struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_new(struct LDKOutPoint outpoint_arg, struct LDKPublicKey per_commitment_point_arg, uint16_t to_self_delay_arg, struct LDKTxOut output_arg, struct LDKPublicKey revocation_pubkey_arg, struct LDKThirtyTwoBytes channel_keys_id_arg, uint64_t channel_value_satoshis_arg);
+ export function DelayedPaymentOutputDescriptor_new(outpoint_arg: number, per_commitment_point_arg: Uint8Array, to_self_delay_arg: number, output_arg: number, revocation_pubkey_arg: Uint8Array, channel_keys_id_arg: Uint8Array, channel_value_satoshis_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Persist_free(this_ptr);
- // debug statements here
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_new(outpoint_arg, encodeArray(per_commitment_point_arg), to_self_delay_arg, output_arg, encodeArray(revocation_pubkey_arg), encodeArray(channel_keys_id_arg), channel_value_satoshis_arg);
+ return nativeResponseValue;
}
- // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
- export function C2Tuple_BlockHashChannelMonitorZ_read(ser: Uint8Array, arg: number): number {
+ // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
+ export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_read(encodeArray(ser), arg);
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_clone(orig);
return nativeResponseValue;
}
- // void OutPoint_free(struct LDKOutPoint this_ptr);
- export function OutPoint_free(this_ptr: number): void {
+ // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_ptr);
+ export function StaticPaymentOutputDescriptor_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OutPoint_free(this_ptr);
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_free(this_ptr);
// debug statements here
}
- // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
- export function OutPoint_get_txid(this_ptr: number): Uint8Array {
+ // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
+ export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OutPoint_get_txid(this_ptr);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
+ return nativeResponseValue;
}
- // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
- export function OutPoint_set_txid(this_ptr: number, val: Uint8Array): void {
+ // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
+ export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OutPoint_set_txid(this_ptr, encodeArray(val));
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
// debug statements here
}
- // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
- export function OutPoint_get_index(this_ptr: number): number {
+ // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
+ export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OutPoint_get_index(this_ptr);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_set_output(this_ptr, val);
+ // debug statements here
}
- // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
- export function OutPoint_set_index(this_ptr: number, val: number): void {
+ // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
+ export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OutPoint_set_index(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
+ return decodeArray(nativeResponseValue);
}
- // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
- export function OutPoint_new(txid_arg: Uint8Array, index_arg: number): number {
+ // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+ export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OutPoint_new(encodeArray(txid_arg), index_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, encodeArray(val));
+ // debug statements here
}
- // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
- export function OutPoint_clone(orig: number): number {
+ // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
+ export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OutPoint_clone(orig);
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
- export function OutPoint_to_channel_id(this_arg: number): Uint8Array {
+ // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
+ export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OutPoint_to_channel_id(this_arg);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
+ // debug statements here
}
- // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
- export function OutPoint_write(obj: number): Uint8Array {
+ // MUST_USE_RES struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut output_arg, struct LDKThirtyTwoBytes channel_keys_id_arg, uint64_t channel_value_satoshis_arg);
+ export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: Uint8Array, channel_value_satoshis_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OutPoint_write(obj);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, encodeArray(channel_keys_id_arg), channel_value_satoshis_arg);
+ return nativeResponseValue;
}
- // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
- export function OutPoint_read(ser: Uint8Array): number {
+ // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
+ export function StaticPaymentOutputDescriptor_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OutPoint_read(encodeArray(ser));
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_clone(orig);
return nativeResponseValue;
}
// void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
const nativeResponseValue = wasm.SpendableOutputDescriptor_read(encodeArray(ser));
return nativeResponseValue;
}
- // struct LDKChannelKeys ChannelKeys_clone(const struct LDKChannelKeys *NONNULL_PTR orig);
- export function ChannelKeys_clone(orig: number): number {
+ // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
+ export function Sign_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_clone(orig);
+ const nativeResponseValue = wasm.Sign_clone(orig);
return nativeResponseValue;
}
- // void ChannelKeys_free(struct LDKChannelKeys this_ptr);
- export function ChannelKeys_free(this_ptr: number): void {
+ // void Sign_free(struct LDKSign this_ptr);
+ export function Sign_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelKeys_free(this_ptr);
+ const nativeResponseValue = wasm.Sign_free(this_ptr);
// debug statements here
}
// void KeysInterface_free(struct LDKKeysInterface this_ptr);
const nativeResponseValue = wasm.KeysInterface_free(this_ptr);
// debug statements here
}
- // void InMemoryChannelKeys_free(struct LDKInMemoryChannelKeys this_ptr);
- export function InMemoryChannelKeys_free(this_ptr: number): void {
+ // void InMemorySigner_free(struct LDKInMemorySigner this_ptr);
+ export function InMemorySigner_free(this_ptr: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_free(this_ptr);
+ const nativeResponseValue = wasm.InMemorySigner_free(this_ptr);
// debug statements here
}
- // const uint8_t (*InMemoryChannelKeys_get_funding_key(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32];
- export function InMemoryChannelKeys_get_funding_key(this_ptr: number): Uint8Array {
+ // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
+ export function InMemorySigner_get_funding_key(this_ptr: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_get_funding_key(this_ptr);
+ const nativeResponseValue = wasm.InMemorySigner_get_funding_key(this_ptr);
return decodeArray(nativeResponseValue);
}
- // void InMemoryChannelKeys_set_funding_key(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKSecretKey val);
- export function InMemoryChannelKeys_set_funding_key(this_ptr: number, val: Uint8Array): void {
+ // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
+ export function InMemorySigner_set_funding_key(this_ptr: number, val: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_set_funding_key(this_ptr, encodeArray(val));
+ const nativeResponseValue = wasm.InMemorySigner_set_funding_key(this_ptr, encodeArray(val));
// debug statements here
}
- // const uint8_t (*InMemoryChannelKeys_get_revocation_base_key(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32];
- export function InMemoryChannelKeys_get_revocation_base_key(this_ptr: number): Uint8Array {
+ // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
+ export function InMemorySigner_get_revocation_base_key(this_ptr: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_get_revocation_base_key(this_ptr);
+ const nativeResponseValue = wasm.InMemorySigner_get_revocation_base_key(this_ptr);
return decodeArray(nativeResponseValue);
}
- // void InMemoryChannelKeys_set_revocation_base_key(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKSecretKey val);
- export function InMemoryChannelKeys_set_revocation_base_key(this_ptr: number, val: Uint8Array): void {
+ // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
+ export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_set_revocation_base_key(this_ptr, encodeArray(val));
+ const nativeResponseValue = wasm.InMemorySigner_set_revocation_base_key(this_ptr, encodeArray(val));
// debug statements here
}
- // const uint8_t (*InMemoryChannelKeys_get_payment_key(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32];
- export function InMemoryChannelKeys_get_payment_key(this_ptr: number): Uint8Array {
+ // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
+ export function InMemorySigner_get_payment_key(this_ptr: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_get_payment_key(this_ptr);
+ const nativeResponseValue = wasm.InMemorySigner_get_payment_key(this_ptr);
return decodeArray(nativeResponseValue);
}
- // void InMemoryChannelKeys_set_payment_key(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKSecretKey val);
- export function InMemoryChannelKeys_set_payment_key(this_ptr: number, val: Uint8Array): void {
+ // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
+ export function InMemorySigner_set_payment_key(this_ptr: number, val: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_set_payment_key(this_ptr, encodeArray(val));
+ const nativeResponseValue = wasm.InMemorySigner_set_payment_key(this_ptr, encodeArray(val));
// debug statements here
}
- // const uint8_t (*InMemoryChannelKeys_get_delayed_payment_base_key(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32];
- export function InMemoryChannelKeys_get_delayed_payment_base_key(this_ptr: number): Uint8Array {
+ // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
+ export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_get_delayed_payment_base_key(this_ptr);
+ const nativeResponseValue = wasm.InMemorySigner_get_delayed_payment_base_key(this_ptr);
return decodeArray(nativeResponseValue);
}
- // void InMemoryChannelKeys_set_delayed_payment_base_key(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKSecretKey val);
- export function InMemoryChannelKeys_set_delayed_payment_base_key(this_ptr: number, val: Uint8Array): void {
+ // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
+ export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_set_delayed_payment_base_key(this_ptr, encodeArray(val));
+ const nativeResponseValue = wasm.InMemorySigner_set_delayed_payment_base_key(this_ptr, encodeArray(val));
// debug statements here
}
- // const uint8_t (*InMemoryChannelKeys_get_htlc_base_key(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32];
- export function InMemoryChannelKeys_get_htlc_base_key(this_ptr: number): Uint8Array {
+ // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
+ export function InMemorySigner_get_htlc_base_key(this_ptr: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_get_htlc_base_key(this_ptr);
+ const nativeResponseValue = wasm.InMemorySigner_get_htlc_base_key(this_ptr);
return decodeArray(nativeResponseValue);
}
- // void InMemoryChannelKeys_set_htlc_base_key(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKSecretKey val);
- export function InMemoryChannelKeys_set_htlc_base_key(this_ptr: number, val: Uint8Array): void {
+ // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
+ export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_set_htlc_base_key(this_ptr, encodeArray(val));
+ const nativeResponseValue = wasm.InMemorySigner_set_htlc_base_key(this_ptr, encodeArray(val));
// debug statements here
}
- // const uint8_t (*InMemoryChannelKeys_get_commitment_seed(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32];
- export function InMemoryChannelKeys_get_commitment_seed(this_ptr: number): Uint8Array {
+ // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
+ export function InMemorySigner_get_commitment_seed(this_ptr: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_get_commitment_seed(this_ptr);
+ const nativeResponseValue = wasm.InMemorySigner_get_commitment_seed(this_ptr);
return decodeArray(nativeResponseValue);
}
- // void InMemoryChannelKeys_set_commitment_seed(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
- export function InMemoryChannelKeys_set_commitment_seed(this_ptr: number, val: Uint8Array): void {
+ // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+ export function InMemorySigner_set_commitment_seed(this_ptr: number, val: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_set_commitment_seed(this_ptr, encodeArray(val));
+ const nativeResponseValue = wasm.InMemorySigner_set_commitment_seed(this_ptr, encodeArray(val));
// debug statements here
}
- // struct LDKInMemoryChannelKeys InMemoryChannelKeys_clone(const struct LDKInMemoryChannelKeys *NONNULL_PTR orig);
- export function InMemoryChannelKeys_clone(orig: number): number {
+ // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
+ export function InMemorySigner_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InMemorySigner_clone(orig);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKInMemorySigner InMemorySigner_new(struct LDKSecretKey funding_key, struct LDKSecretKey revocation_base_key, struct LDKSecretKey payment_key, struct LDKSecretKey delayed_payment_base_key, struct LDKSecretKey htlc_base_key, struct LDKThirtyTwoBytes commitment_seed, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
+ export function InMemorySigner_new(funding_key: Uint8Array, revocation_base_key: Uint8Array, payment_key: Uint8Array, delayed_payment_base_key: Uint8Array, htlc_base_key: Uint8Array, commitment_seed: Uint8Array, channel_value_satoshis: number, channel_keys_id: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InMemorySigner_new(encodeArray(funding_key), encodeArray(revocation_base_key), encodeArray(payment_key), encodeArray(delayed_payment_base_key), encodeArray(htlc_base_key), encodeArray(commitment_seed), channel_value_satoshis, encodeArray(channel_keys_id));
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
+ export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_clone(orig);
+ const nativeResponseValue = wasm.InMemorySigner_counterparty_pubkeys(this_arg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKInMemoryChannelKeys InMemoryChannelKeys_new(struct LDKSecretKey funding_key, struct LDKSecretKey revocation_base_key, struct LDKSecretKey payment_key, struct LDKSecretKey delayed_payment_base_key, struct LDKSecretKey htlc_base_key, struct LDKThirtyTwoBytes commitment_seed, uint64_t channel_value_satoshis, struct LDKC2Tuple_u64u64Z key_derivation_params);
- export function InMemoryChannelKeys_new(funding_key: Uint8Array, revocation_base_key: Uint8Array, payment_key: Uint8Array, delayed_payment_base_key: Uint8Array, htlc_base_key: Uint8Array, commitment_seed: Uint8Array, channel_value_satoshis: number, key_derivation_params: number): number {
+ // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
+ export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_new(encodeArray(funding_key), encodeArray(revocation_base_key), encodeArray(payment_key), encodeArray(delayed_payment_base_key), encodeArray(htlc_base_key), encodeArray(commitment_seed), channel_value_satoshis, key_derivation_params);
+ const nativeResponseValue = wasm.InMemorySigner_counterparty_selected_contest_delay(this_arg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKChannelPublicKeys InMemoryChannelKeys_counterparty_pubkeys(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg);
- export function InMemoryChannelKeys_counterparty_pubkeys(this_arg: number): number {
+ // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
+ export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_counterparty_pubkeys(this_arg);
+ const nativeResponseValue = wasm.InMemorySigner_holder_selected_contest_delay(this_arg);
return nativeResponseValue;
}
- // MUST_USE_RES uint16_t InMemoryChannelKeys_counterparty_selected_contest_delay(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg);
- export function InMemoryChannelKeys_counterparty_selected_contest_delay(this_arg: number): number {
+ // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
+ export function InMemorySigner_is_outbound(this_arg: number): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_counterparty_selected_contest_delay(this_arg);
+ const nativeResponseValue = wasm.InMemorySigner_is_outbound(this_arg);
return nativeResponseValue;
}
- // MUST_USE_RES uint16_t InMemoryChannelKeys_holder_selected_contest_delay(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg);
- export function InMemoryChannelKeys_holder_selected_contest_delay(this_arg: number): number {
+ // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
+ export function InMemorySigner_funding_outpoint(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_holder_selected_contest_delay(this_arg);
+ const nativeResponseValue = wasm.InMemorySigner_funding_outpoint(this_arg);
return nativeResponseValue;
}
- // MUST_USE_RES bool InMemoryChannelKeys_is_outbound(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg);
- export function InMemoryChannelKeys_is_outbound(this_arg: number): boolean {
+ // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
+ export function InMemorySigner_get_channel_parameters(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_is_outbound(this_arg);
+ const nativeResponseValue = wasm.InMemorySigner_get_channel_parameters(this_arg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKOutPoint InMemoryChannelKeys_funding_outpoint(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg);
- export function InMemoryChannelKeys_funding_outpoint(this_arg: number): number {
+ // MUST_USE_RES struct LDKCResult_CVec_CVec_u8ZZNoneZ InMemorySigner_sign_counterparty_payment_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR descriptor);
+ export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: Uint8Array, input_idx: number, descriptor: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_funding_outpoint(this_arg);
+ const nativeResponseValue = wasm.InMemorySigner_sign_counterparty_payment_input(this_arg, encodeArray(spend_tx), input_idx, descriptor);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKChannelTransactionParameters InMemoryChannelKeys_get_channel_parameters(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg);
- export function InMemoryChannelKeys_get_channel_parameters(this_arg: number): number {
+ // MUST_USE_RES struct LDKCResult_CVec_CVec_u8ZZNoneZ InMemorySigner_sign_dynamic_p2wsh_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR descriptor);
+ export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: Uint8Array, input_idx: number, descriptor: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_get_channel_parameters(this_arg);
+ const nativeResponseValue = wasm.InMemorySigner_sign_dynamic_p2wsh_input(this_arg, encodeArray(spend_tx), input_idx, descriptor);
return nativeResponseValue;
}
- // struct LDKChannelKeys InMemoryChannelKeys_as_ChannelKeys(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg);
- export function InMemoryChannelKeys_as_ChannelKeys(this_arg: number): number {
+ // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
+ export function InMemorySigner_as_Sign(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_as_ChannelKeys(this_arg);
+ const nativeResponseValue = wasm.InMemorySigner_as_Sign(this_arg);
return nativeResponseValue;
}
- // struct LDKCVec_u8Z InMemoryChannelKeys_write(const struct LDKInMemoryChannelKeys *NONNULL_PTR obj);
- export function InMemoryChannelKeys_write(obj: number): Uint8Array {
+ // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
+ export function InMemorySigner_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_write(obj);
+ const nativeResponseValue = wasm.InMemorySigner_write(obj);
return decodeArray(nativeResponseValue);
}
- // struct LDKCResult_InMemoryChannelKeysDecodeErrorZ InMemoryChannelKeys_read(struct LDKu8slice ser);
- export function InMemoryChannelKeys_read(ser: Uint8Array): number {
+ // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser);
+ export function InMemorySigner_read(ser: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemoryChannelKeys_read(encodeArray(ser));
+ const nativeResponseValue = wasm.InMemorySigner_read(encodeArray(ser));
return nativeResponseValue;
}
// void KeysManager_free(struct LDKKeysManager this_ptr);
const nativeResponseValue = wasm.KeysManager_free(this_ptr);
// debug statements here
}
- // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], enum LDKNetwork network, uint64_t starting_time_secs, uint32_t starting_time_nanos);
- export function KeysManager_new(seed: Uint8Array, network: LDKNetwork, starting_time_secs: number, starting_time_nanos: number): number {
+ // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
+ export function KeysManager_new(seed: Uint8Array, starting_time_secs: number, starting_time_nanos: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.KeysManager_new(encodeArray(seed), starting_time_secs, starting_time_nanos);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKInMemorySigner KeysManager_derive_channel_keys(const struct LDKKeysManager *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, const uint8_t (*params)[32]);
+ export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: number, params: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.KeysManager_new(encodeArray(seed), network, starting_time_secs, starting_time_nanos);
+ const nativeResponseValue = wasm.KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, encodeArray(params));
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKInMemoryChannelKeys KeysManager_derive_channel_keys(const struct LDKKeysManager *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, uint64_t params_1, uint64_t params_2);
- export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: number, params_1: number, params_2: number): number {
+ // MUST_USE_RES struct LDKCResult_TransactionNoneZ KeysManager_spend_spendable_outputs(const struct LDKKeysManager *NONNULL_PTR this_arg, struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight);
+ export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number[], outputs: number[], change_destination_script: Uint8Array, feerate_sat_per_1000_weight: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params_1, params_2);
+ const nativeResponseValue = wasm.KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, encodeArray(change_destination_script), feerate_sat_per_1000_weight);
return nativeResponseValue;
}
// struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
const nativeResponseValue = wasm.ChannelManager_free(this_ptr);
// debug statements here
}
+ // void ChainParameters_free(struct LDKChainParameters this_ptr);
+ export function ChainParameters_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainParameters_free(this_ptr);
+ // debug statements here
+ }
+ // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
+ export function ChainParameters_get_network(this_ptr: number): LDKNetwork {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainParameters_get_network(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
+ export function ChainParameters_set_network(this_ptr: number, val: LDKNetwork): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainParameters_set_network(this_ptr, val);
+ // debug statements here
+ }
+ // const uint8_t (*ChainParameters_get_latest_hash(const struct LDKChainParameters *NONNULL_PTR this_ptr))[32];
+ export function ChainParameters_get_latest_hash(this_ptr: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainParameters_get_latest_hash(this_ptr);
+ return decodeArray(nativeResponseValue);
+ }
+ // void ChainParameters_set_latest_hash(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+ export function ChainParameters_set_latest_hash(this_ptr: number, val: Uint8Array): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainParameters_set_latest_hash(this_ptr, encodeArray(val));
+ // debug statements here
+ }
+ // uintptr_t ChainParameters_get_latest_height(const struct LDKChainParameters *NONNULL_PTR this_ptr);
+ export function ChainParameters_get_latest_height(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainParameters_get_latest_height(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChainParameters_set_latest_height(struct LDKChainParameters *NONNULL_PTR this_ptr, uintptr_t val);
+ export function ChainParameters_set_latest_height(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainParameters_set_latest_height(this_ptr, val);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKThirtyTwoBytes latest_hash_arg, uintptr_t latest_height_arg);
+ export function ChainParameters_new(network_arg: LDKNetwork, latest_hash_arg: Uint8Array, latest_height_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainParameters_new(network_arg, encodeArray(latest_hash_arg), latest_height_arg);
+ return nativeResponseValue;
+ }
// void ChannelDetails_free(struct LDKChannelDetails this_ptr);
export function ChannelDetails_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.PaymentSendFailure_clone(orig);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKChannelManager ChannelManager_new(enum LDKNetwork network, struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKKeysInterface keys_manager, struct LDKUserConfig config, uintptr_t current_blockchain_height);
- export function ChannelManager_new(network: LDKNetwork, fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, current_blockchain_height: number): number {
+ // 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) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelManager_new(network, fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, current_blockchain_height);
+ const nativeResponseValue = wasm.ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
return nativeResponseValue;
}
// MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_create_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, uint64_t user_id, struct LDKUserConfig override_config);
const nativeResponseValue = wasm.ChannelManager_as_EventsProvider(this_arg);
return nativeResponseValue;
}
+ // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ export function ChannelManager_as_Listen(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelManager_as_Listen(this_arg);
+ return nativeResponseValue;
+ }
// void ChannelManager_block_connected(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
export function ChannelManager_block_connected(this_arg: number, header: Uint8Array, txdata: number[], height: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelManager_block_disconnected(this_arg, encodeArray(header));
// debug statements here
}
+ // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ export function ChannelManager_await_persistable_update(this_arg: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelManager_await_persistable_update(this_arg);
+ // debug statements here
+ }
// 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.Init_free(this_ptr);
// debug statements here
}
+ // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
+ export function Init_get_features(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Init_get_features(this_ptr);
+ return nativeResponseValue;
+ }
+ // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
+ export function Init_set_features(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Init_set_features(this_ptr, val);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg);
+ export function Init_new(features_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Init_new(features_arg);
+ return nativeResponseValue;
+ }
// struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
export function Init_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.GossipTimestampFilter_write(obj);
return decodeArray(nativeResponseValue);
}
+ // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_ptr);
+ export function IgnoringMessageHandler_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.IgnoringMessageHandler_free(this_ptr);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
+ export function IgnoringMessageHandler_new(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.IgnoringMessageHandler_new();
+ return nativeResponseValue;
+ }
+ // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
+ export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
+ return nativeResponseValue;
+ }
+ // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
+ export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
+ return nativeResponseValue;
+ }
+ // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_ptr);
+ export function ErroringMessageHandler_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ErroringMessageHandler_free(this_ptr);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
+ export function ErroringMessageHandler_new(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ErroringMessageHandler_new();
+ return nativeResponseValue;
+ }
+ // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
+ export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
+ return nativeResponseValue;
+ }
+ // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
+ export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
+ return nativeResponseValue;
+ }
// void MessageHandler_free(struct LDKMessageHandler this_ptr);
export function MessageHandler_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RouteHint_set_cltv_expiry_delta(this_ptr, val);
// debug statements here
}
- // uint64_t RouteHint_get_htlc_minimum_msat(const struct LDKRouteHint *NONNULL_PTR this_ptr);
- export function RouteHint_get_htlc_minimum_msat(this_ptr: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.RouteHint_get_htlc_minimum_msat(this_ptr);
- return nativeResponseValue;
- }
- // void RouteHint_set_htlc_minimum_msat(struct LDKRouteHint *NONNULL_PTR this_ptr, uint64_t val);
- export function RouteHint_set_htlc_minimum_msat(this_ptr: number, val: number): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.RouteHint_set_htlc_minimum_msat(this_ptr, val);
- // debug statements here
- }
- // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKPublicKey src_node_id_arg, uint64_t short_channel_id_arg, struct LDKRoutingFees fees_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg);
- export function RouteHint_new(src_node_id_arg: Uint8Array, short_channel_id_arg: number, fees_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.RouteHint_new(encodeArray(src_node_id_arg), short_channel_id_arg, fees_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg);
- return nativeResponseValue;
- }
// struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
export function RouteHint_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RouteHint_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_RouteLightningErrorZ get_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey target, 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_route(our_node_id: Uint8Array, network: number, target: Uint8Array, first_hops: number[], last_hops: number[], final_value_msat: number, final_cltv: number, logger: number): number {
+ // struct LDKCResult_RouteLightningErrorZ get_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_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.get_route(encodeArray(our_node_id), network, encodeArray(target), first_hops, last_hops, final_value_msat, final_cltv, logger);
+ const nativeResponseValue = wasm.get_route(encodeArray(our_node_id), network, encodeArray(payee), first_hops, last_hops, final_value_msat, final_cltv, logger);
return nativeResponseValue;
}
// void NetworkGraph_free(struct LDKNetworkGraph this_ptr);
const nativeResponseValue = wasm.NetworkGraph_free(this_ptr);
// debug statements here
}
+ // struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
+ export function NetworkGraph_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetworkGraph_clone(orig);
+ return nativeResponseValue;
+ }
// void LockedNetworkGraph_free(struct LDKLockedNetworkGraph this_ptr);
export function LockedNetworkGraph_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.NetGraphMsgHandler_from_net_graph(chain_access, logger, network_graph);
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 {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.NetGraphMsgHandler_add_chain_access(this_arg, chain_access);
+ // 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 {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelInfo_set_announcement_message(this_ptr, val);
// debug statements here
}
+ // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
+ export function ChannelInfo_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelInfo_clone(orig);
+ return nativeResponseValue;
+ }
// struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
export function ChannelInfo_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
projects / ldk-java / blobdiff