Select free ports for lnd from a pool of options. By default we will
use the standard lnd ports (10009 and 9735) but if those are not
available then we will search for free ports in a nearby range.
This allows us to have multiple instances of the wallet running and
avoids possible conflicts with other instances of lnd that the user
may be running.
Ensure that logs are output when the app is run in production mode. not
only development mode so that its easier to diagnose an issue with a
production build.
Lnd doesn't currently do a graceful shutdown when a `SIGTERM` is issued.
To ensure a graceful shutdown, call `stopDaemon` on the gRPC interface
prior to terminating lnd. If a graceful shutdown is unsuccessful then
force kill the daemon.
During the sync process there are log message that relate to syncing
filters and filter headers. This fixes an issue where we were parsing
messages about syncing filters as if they were filter headers, which
would cause the progress indicator to jump around during the middle of
the sync process due to it thinking that more filter headers had been
synced than was actually the case.
Handle the case were the Neutrino backend BTCd node is still
synchronising the blockchain as LND is not able to start syncing
until the BTCd node that it is connected to is fully synced.
Fetch the current block height from multiple block explorers early on in
the sync process. This ensures that we get the correct block height in
the case where our BTCd node is still mid way through syncing. Do this
in the main process rather than in the render process.
When matching log lines, switch on the regex match rather than an
excerpt, so that there are never any false positives.
Note this allows conditional assignment within parens as well.
Determine the current block height directly from the lnd log output and
pass the data into the app as soon as we have it. Do not call out to
block explorers if we don't need to.
`main.dev.js` was hard to follow and understand the code flow. It housed
code to handle quite a few distinct things. This is a fairly substantial
refactor of the application startup code in which we:
A new `Neutrino` class has been created with 2 public methods. `start`
and `stop`. `start` will launch a new `lnd` process whilst `stop` will
stop it. This class extends the `EventEmitter` class and emits the
following events based on activity detected from the lnd log output.
- `grpc-proxy-started` - gRPC started
- `wallet-opened` Wallet opened
- `fully-synced` - lnd is all caught up to the blockchain
- `got-block-height` - got updated block height
A new `ZapController` class has been created which houses all of the
logic for intraprocess communication between the main and renderer
processes.
Previously we had several `setInterval` loops that were checking every
second to see if the application status has changed and trigging the
appropriate action if so. This was pretty hard to follow has been
replaced here with more extensive use of promises. This enables us to
act instantly to relevant changes rather than waiting up to 1 second
for the next interval to fire.
Now, the only stuff that lives in `main.dev.js` now is the top level
`app` listeners, which calls out the other parts mentioned above to
bootstrap the application.
Tom Kirkpatrick
Ben Woosley