1 import * as ldk from "lightningdevkit";
2 import * as net from "net";
5 * Handles TCP connections using Node.JS's 'net' module given an `ldk.PeerManager`.
7 export class NodeLDKNet {
9 private servers: net.Server[];
10 public constructor(public peer_manager: ldk.PeerManager) {
11 this.ping_timer = setInterval(function() {
12 peer_manager.timer_tick_occurred();
13 peer_manager.process_events();
19 * Disconnects all connections and releases all resources for this net handler.
22 clearInterval(this.ping_timer);
23 for (const server of this.servers) {
26 this.peer_manager.disconnect_all_peers();
30 * Processes any pending events for the PeerManager, sending queued messages.
31 * You should call this (or peer_manager.process_events()) any time you take an action which
32 * is likely to generate messages to send (eg send a payment, processing payment forwards,
35 public process_events() { this.peer_manager.process_events(); }
37 private descriptor_count = BigInt(0);
38 private get_descriptor(socket: net.Socket): ldk.SocketDescriptor {
39 const this_index = this.descriptor_count;
40 this.descriptor_count += BigInt(1);
42 socket.setNoDelay(true);
44 const this_pm = this.peer_manager;
45 var sock_write_waiting = false;
47 let descriptor = ldk.SocketDescriptor.new_impl ({
48 send_data(data: Uint8Array, resume_read: boolean): number {
49 if (resume_read) socket.resume();
51 if (sock_write_waiting) return 0;
52 const written = socket.write(data);
53 if (!written) sock_write_waiting = true;
56 disconnect_socket(): void {
59 eq(other: ldk.SocketDescriptor): boolean {
60 return other.hash() == this.hash();
65 } as ldk.SocketDescriptorInterface);
67 socket.on("drain", function() {
68 if (sock_write_waiting) {
69 if (!this_pm.write_buffer_space_avail(descriptor).is_ok()) {
70 descriptor.disconnect_socket();
75 socket.on("data", function(data) {
76 const res = this_pm.read_event(descriptor, data);
77 if (!res.is_ok()) descriptor.disconnect_socket();
78 else if ((res as ldk.Result_boolPeerHandleErrorZ_OK).res) socket.pause();
79 this_pm.process_events();
82 socket.on("close", function() {
83 this_pm.socket_disconnected(descriptor);
85 socket.on("error", function() {
86 this_pm.socket_disconnected(descriptor);
92 private static v4_addr_from_ip(ip: string, port: number): ldk.NetAddress {
93 const sockaddr = ip.split(".").map(parseFloat);
94 return ldk.NetAddress.constructor_ipv4(new Uint8Array(sockaddr), port);
96 private static v6_addr_from_ip(ip: string, port: number): ldk.NetAddress {
97 const sockaddr = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
98 const halves = ip.split("::"); // either one or two elements
99 const first_half = halves[0].split(":");
100 for (var idx = 0; idx < first_half.length; idx++) {
101 const v = parseInt(first_half[idx], 16);
102 sockaddr[idx*2] = v >> 8;
103 sockaddr[idx*2 + 1] = v & 0xff;
105 if (halves.length == 2) {
106 const second_half = halves[1].split(":");
107 for (var idx = 0; idx < second_half.length; idx++) {
108 const v = parseInt(second_half[second_half.length - idx - 1], 16);
109 sockaddr[14 - idx*2] = v >> 8;
110 sockaddr[15 - idx*2] = v & 0xff;
113 return ldk.NetAddress.constructor_ipv6(new Uint8Array(sockaddr), port);
116 private static get_addr_from_socket(socket: net.Socket): ldk.Option_NetAddressZ {
117 const addr = socket.remoteAddress;
118 if (addr === undefined)
119 return ldk.Option_NetAddressZ.constructor_none();
120 if (net.isIPv4(addr)) {
121 return ldk.Option_NetAddressZ.constructor_some(NodeLDKNet.v4_addr_from_ip(addr, socket.remotePort));
123 if (net.isIPv6(addr)) {
124 return ldk.Option_NetAddressZ.constructor_some(NodeLDKNet.v6_addr_from_ip(addr, socket.remotePort));
126 return ldk.Option_NetAddressZ.constructor_none();
130 * Binds a listener on the given host and port, accepting incoming connections.
132 public async bind_listener(host: string, port: number) {
133 const this_handler = this;
134 const server = net.createServer(function(incoming_sock: net.Socket) {
135 const descriptor = this_handler.get_descriptor(incoming_sock);
136 const res = this_handler.peer_manager
137 .new_inbound_connection(descriptor, NodeLDKNet.get_addr_from_socket(incoming_sock));
138 if (!res.is_ok()) descriptor.disconnect_socket();
140 const servers_list = this.servers;
141 return new Promise<void>((resolve, reject) => {
142 server.on("error", function() {
146 server.on("listening", function() {
147 servers_list.push(server);
150 server.listen(port, host);
155 * Establishes an outgoing connection to the given peer at the given host and port.
157 * Note that the peer will not appear in the PeerManager peers list until the socket has
158 * connected and the initial handshake completes.
160 public async connect_peer(host: string, port: number, peer_node_id: Uint8Array) {
161 const this_handler = this;
162 const sock = new net.Socket();
163 const res = new Promise<void>((resolve, reject) => {
164 sock.on("connect", function() { resolve(); });
165 sock.on("error", function() { reject(); });
167 sock.connect(port, host, function() {
168 const descriptor = this_handler.get_descriptor(sock);
169 const res = this_handler.peer_manager
170 .new_outbound_connection(peer_node_id, descriptor, NodeLDKNet.get_addr_from_socket(sock));
171 if (!res.is_ok()) descriptor.disconnect_socket();
173 const bytes = (res as ldk.Result_CVec_u8ZPeerHandleErrorZ_OK).res;
174 const send_res = descriptor.send_data(bytes, true);
175 console.assert(send_res == bytes.length);