const tests: Array<Function> = [];
+function assert(val: boolean) {
+ if (!val) throw new Error("Assertion failed");
+}
function array_eq(a: Uint8Array, b: Uint8Array): boolean {
return a.length == b.length && a.every((v, idx) => v == b[idx]);
}
tests.push(async () => {
const result = rawldk.CResult_boolLightningErrorZ_ok(true);
- console.assert(rawldk.CResult_boolLightningErrorZ_is_ok(result));
- console.assert(rawldk.CResult_boolLightningErrorZ_get_ok(result));
+ assert(rawldk.CResult_boolLightningErrorZ_is_ok(result));
+ assert(rawldk.CResult_boolLightningErrorZ_get_ok(result));
rawldk.CResult_boolLightningErrorZ_free(result);
const second_res = rawldk.CResult_boolLightningErrorZ_ok(false);
- console.assert(rawldk.CResult_boolLightningErrorZ_is_ok(second_res));
- console.assert(!rawldk.CResult_boolLightningErrorZ_get_ok(second_res));
+ assert(rawldk.CResult_boolLightningErrorZ_is_ok(second_res));
+ assert(!rawldk.CResult_boolLightningErrorZ_get_ok(second_res));
rawldk.CResult_boolLightningErrorZ_free(second_res);
return true;
}
function get_chanman(): Node {
const fee_est = ldk.FeeEstimator.new_impl({
- get_est_sat_per_1000_weight(confirmation_target: ldk.ConfirmationTarget): number {
+ get_est_sat_per_1000_weight(_confirmation_target: ldk.ConfirmationTarget): number {
return 253;
}
} as ldk.FeeEstimatorInterface);
- var tx_broadcaster;
- const tx_broadcasted: Promise<Uint8Array> = new Promise((resolve, reject) => {
+ var tx_broadcaster: ldk.BroadcasterInterface;
+ const tx_broadcasted: Promise<Uint8Array> = new Promise((resolve, _reject) => {
tx_broadcaster = ldk.BroadcasterInterface.new_impl({
broadcast_transaction(tx: Uint8Array): void { console.log("Tx Broadcast: " + tx); resolve(tx); }
} as ldk.BroadcasterInterfaceInterface);
} as ldk.LoggerInterface);
const persister = ldk.Persist.new_impl({
- persist_new_channel(channel_id: ldk.OutPoint, data: ldk.ChannelMonitor, update_id: ldk.MonitorUpdateId): ldk.ChannelMonitorUpdateStatus {
+ persist_new_channel(_channel_id: ldk.OutPoint, _data: ldk.ChannelMonitor, _update_id: ldk.MonitorUpdateId): ldk.ChannelMonitorUpdateStatus {
return ldk.ChannelMonitorUpdateStatus.LDKChannelMonitorUpdateStatus_Completed;
},
- update_persisted_channel(channel_id: ldk.OutPoint, update: ldk.ChannelMonitorUpdate, data: ldk.ChannelMonitor, update_id: ldk.MonitorUpdateId): ldk.ChannelMonitorUpdateStatus {
+ update_persisted_channel(_channel_id: ldk.OutPoint, _update: ldk.ChannelMonitorUpdate, _data: ldk.ChannelMonitor, _update_id: ldk.MonitorUpdateId): ldk.ChannelMonitorUpdateStatus {
return ldk.ChannelMonitorUpdateStatus.LDKChannelMonitorUpdateStatus_Completed;
}
} as ldk.PersistInterface);
- const chain_monitor = ldk.ChainMonitor.constructor_new(ldk.Option_FilterZ.constructor_none(), tx_broadcaster, logger, fee_est, persister);
+ const chain_monitor = ldk.ChainMonitor.constructor_new(ldk.Option_FilterZ.constructor_none(), tx_broadcaster!, logger, fee_est, persister);
const chain_watch: ldk.Watch = chain_monitor.as_Watch();
const seed = new Uint8Array(32);
const config = ldk.UserConfig.constructor_default();
const params = ldk.ChainParameters.constructor_new(ldk.Network.LDKNetwork_Testnet, ldk.BestBlock.constructor_from_genesis(ldk.Network.LDKNetwork_Testnet));
- const chan_man = ldk.ChannelManager.constructor_new(fee_est, chain_watch, tx_broadcaster, logger, keys_interface, config, params);
+ const chan_man = ldk.ChannelManager.constructor_new(fee_est, chain_watch, tx_broadcaster!, logger, keys_interface, config, params);
return new Node(chan_man, tx_broadcasted, logger, keys_interface);
}
} as ldk.EventHandlerInterface);
chan_man.as_EventsProvider().process_pending_events(event_handler);
- console.assert(events.length == 1);
- return events[0];
+ assert(events.length == 1);
+ return events[0]!;
}
tests.push(async () => {
var sock_b: ldk.SocketDescriptor;
const sock_a = ldk.SocketDescriptor.new_impl({
send_data(data: Uint8Array, resume_read: boolean): number {
- console.assert(pm_b.read_event(sock_b, data) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+ assert(pm_b.read_event(sock_b, data) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+ assert(resume_read);
return data.length;
},
disconnect_socket(): void {
- console.assert(false);
+ assert(false);
},
eq(other: ldk.SocketDescriptor): boolean {
return other.hash() == this.hash();
} as ldk.SocketDescriptorInterface);
sock_b = ldk.SocketDescriptor.new_impl({
send_data(data: Uint8Array, resume_read: boolean): number {
- console.assert(pm_a.read_event(sock_a, data) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+ assert(pm_a.read_event(sock_a, data) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+ assert(resume_read);
return data.length;
},
disconnect_socket(): void {
- console.assert(false);
+ assert(false);
},
eq(other: ldk.SocketDescriptor): boolean {
return other.hash() == this.hash();
if (update_done) return false;
const v4_netaddr = ldk.NetAddress.constructor_ipv4(Uint8Array.from([42,0,42,1]), 9735);
- console.assert(pm_b.new_inbound_connection(sock_b, ldk.Option_NetAddressZ.constructor_some(v4_netaddr)) instanceof ldk.Result_NonePeerHandleErrorZ_OK);
+ assert(pm_b.new_inbound_connection(sock_b, ldk.Option_NetAddressZ.constructor_some(v4_netaddr)) instanceof ldk.Result_NonePeerHandleErrorZ_OK);
const init_bytes = pm_a.new_outbound_connection(b.node_id, sock_a, ldk.Option_NetAddressZ.constructor_none());
if (!(init_bytes instanceof ldk.Result_CVec_u8ZPeerHandleErrorZ_OK)) return false;
- console.assert(pm_b.read_event(sock_b, init_bytes.res) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+ assert(pm_b.read_event(sock_b, init_bytes.res) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
- console.assert(pm_a.get_peer_node_ids().length == 0);
- console.assert(pm_b.get_peer_node_ids().length == 0);
+ assert(pm_a.get_peer_node_ids().length == 0);
+ assert(pm_b.get_peer_node_ids().length == 0);
pm_b.process_events();
pm_a.process_events();
pm_b.process_events();
- console.assert(pm_a.get_peer_node_ids().length == 1);
- console.assert(pm_b.get_peer_node_ids().length == 1);
+ assert(pm_a.get_peer_node_ids().length == 1);
+ assert(pm_b.get_peer_node_ids().length == 1);
const chan_create_res = a.chan_man.create_channel(b.node_id, BigInt(1000000), BigInt(400), BigInt(0), ldk.UserConfig.constructor_default());
if (!chan_create_res.is_ok()) return false;
var a_handled_msg = false;
const om_handler_a = ldk.CustomOnionMessageHandler.new_impl({
read_custom_message(message_type: bigint, buffer: Uint8Array): ldk.Result_COption_CustomOnionMessageContentsZDecodeErrorZ {
- console.assert(message_type == 4343n);
- console.assert(buffer.length == 44);
- for (var i = 0; i < 44; i++) console.assert(buffer[i] == 67);
+ assert(message_type == 4343n);
+ assert(buffer.length == 44);
+ for (var i = 0; i < 44; i++) assert(buffer[i] == 67);
return ldk.Result_COption_CustomOnionMessageContentsZDecodeErrorZ.constructor_ok(ldk.Option_CustomOnionMessageContentsZ.constructor_some(ldk.CustomOnionMessageContents.new_impl({
tlv_type(): bigint { return 9998n; },
- write(): Uint8Array { console.assert(false); return null; }
+ write(): Uint8Array { throw new Error(); }
} as ldk.CustomOnionMessageContentsInterface)));
},
handle_custom_message(msg: ldk.CustomOnionMessageContents) {
- console.assert(msg.tlv_type() == 9998n);
+ assert(msg.tlv_type() == 9998n);
a_handled_msg = true;
},
} as ldk.CustomOnionMessageHandlerInterface);
var b_handled_msg = false;
const om_handler_b = ldk.CustomOnionMessageHandler.new_impl({
read_custom_message(message_type: bigint, buffer: Uint8Array): ldk.Result_COption_CustomOnionMessageContentsZDecodeErrorZ {
- console.assert(message_type == 4242n);
- console.assert(buffer.length == 43);
- for (var i = 0; i < 43; i++) console.assert(buffer[i] == 66);
+ assert(message_type == 4242n);
+ assert(buffer.length == 43);
+ for (var i = 0; i < 43; i++) assert(buffer[i] == 66);
return ldk.Result_COption_CustomOnionMessageContentsZDecodeErrorZ.constructor_ok(ldk.Option_CustomOnionMessageContentsZ.constructor_some(ldk.CustomOnionMessageContents.new_impl({
tlv_type(): bigint { return 9999n; },
- write(): Uint8Array { console.assert(false); return null; }
+ write(): Uint8Array { throw new Error(); }
} as ldk.CustomOnionMessageContentsInterface)));
},
handle_custom_message(msg: ldk.CustomOnionMessageContents) {
- console.assert(msg.tlv_type() == 9999n);
+ assert(msg.tlv_type() == 9999n);
b_handled_msg = true;
},
} as ldk.CustomOnionMessageHandlerInterface);
var sock_b: ldk.SocketDescriptor;
const sock_a = ldk.SocketDescriptor.new_impl({
send_data(data: Uint8Array, resume_read: boolean): number {
- console.assert(pm_b.read_event(sock_b, data) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+ assert(pm_b.read_event(sock_b, data) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+ assert(resume_read);
return data.length;
},
disconnect_socket(): void {
- console.assert(false);
+ assert(false);
},
eq(other: ldk.SocketDescriptor): boolean {
return other.hash() == this.hash();
} as ldk.SocketDescriptorInterface);
sock_b = ldk.SocketDescriptor.new_impl({
send_data(data: Uint8Array, resume_read: boolean): number {
- console.assert(pm_a.read_event(sock_a, data) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+ assert(pm_a.read_event(sock_a, data) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+ assert(resume_read);
return data.length;
},
disconnect_socket(): void {
- console.assert(false);
+ assert(false);
},
eq(other: ldk.SocketDescriptor): boolean {
return other.hash() == this.hash();
} as ldk.SocketDescriptorInterface);
const v4_netaddr = ldk.NetAddress.constructor_ipv4(Uint8Array.from([42,0,42,1]), 9735);
- console.assert(pm_b.new_inbound_connection(sock_b, ldk.Option_NetAddressZ.constructor_some(v4_netaddr)) instanceof ldk.Result_NonePeerHandleErrorZ_OK);
+ assert(pm_b.new_inbound_connection(sock_b, ldk.Option_NetAddressZ.constructor_some(v4_netaddr)) instanceof ldk.Result_NonePeerHandleErrorZ_OK);
const init_bytes = pm_a.new_outbound_connection(b.node_id, sock_a, ldk.Option_NetAddressZ.constructor_none());
if (!(init_bytes instanceof ldk.Result_CVec_u8ZPeerHandleErrorZ_OK)) return false;
- console.assert(pm_b.read_event(sock_b, init_bytes.res) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+ assert(pm_b.read_event(sock_b, init_bytes.res) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
- console.assert(pm_a.get_peer_node_ids().length == 0);
- console.assert(pm_b.get_peer_node_ids().length == 0);
+ assert(pm_a.get_peer_node_ids().length == 0);
+ assert(pm_b.get_peer_node_ids().length == 0);
pm_b.process_events();
pm_a.process_events();
pm_b.process_events();
- console.assert(pm_a.get_peer_node_ids().length == 1);
- console.assert(pm_b.get_peer_node_ids().length == 1);
+ assert(pm_a.get_peer_node_ids().length == 1);
+ assert(pm_b.get_peer_node_ids().length == 1);
underlying_om_a.send_custom_onion_message([], ldk.Destination.constructor_node(b.node_id), ldk.CustomOnionMessageContents.new_impl({
tlv_type(): bigint { return 4242n; },
}
} as ldk.CustomOnionMessageContentsInterface), null);
pm_a.process_events();
- console.assert(b_handled_msg);
+ assert(b_handled_msg);
om_b.send_custom_onion_message([], ldk.Destination.constructor_node(a.node_id), ldk.CustomOnionMessageContents.new_impl({
tlv_type(): bigint { return 4343n; },
}
} as ldk.CustomOnionMessageContentsInterface), null);
pm_b.process_events();
- console.assert(a_handled_msg);
+ assert(a_handled_msg);
return true;
});
console.log("all tests passed: " + result);
if (result !== true || !check_leaks) { return result; }
- const allocs_finished = new Promise((resolve, reject) => {
+ const allocs_finished = new Promise((resolve, _reject) => {
var loop_count = 0;
const interval_id = setInterval(() => {
const alloc_count = rawldk.getRemainingAllocationCount();
projects / ldk-java / blobdiff