106 lines
3.0 KiB
Go
106 lines
3.0 KiB
Go
package wtdb
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"net"
|
|
|
|
"github.com/btcsuite/btcd/btcec"
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
)
|
|
|
|
var (
|
|
// ErrTowerNotFound signals that the target tower was not found in the
|
|
// database.
|
|
ErrTowerNotFound = errors.New("tower not found")
|
|
)
|
|
|
|
// TowerID is a unique 64-bit identifier allocated to each unique watchtower.
|
|
// This allows the client to conserve on-disk space by not needing to always
|
|
// reference towers by their pubkey.
|
|
type TowerID uint64
|
|
|
|
// TowerIDFromBytes constructs a TowerID from the provided byte slice. The
|
|
// argument must have at least 8 bytes, and should contain the TowerID in
|
|
// big-endian byte order.
|
|
func TowerIDFromBytes(towerIDBytes []byte) TowerID {
|
|
return TowerID(byteOrder.Uint64(towerIDBytes))
|
|
}
|
|
|
|
// Bytes encodes a TowerID into an 8-byte slice in big-endian byte order.
|
|
func (id TowerID) Bytes() []byte {
|
|
var buf [8]byte
|
|
byteOrder.PutUint64(buf[:], uint64(id))
|
|
return buf[:]
|
|
}
|
|
|
|
// Tower holds the necessary components required to connect to a remote tower.
|
|
// Communication is handled by brontide, and requires both a public key and an
|
|
// address.
|
|
type Tower struct {
|
|
// ID is a unique ID for this record assigned by the database.
|
|
ID TowerID
|
|
|
|
// IdentityKey is the public key of the remote node, used to
|
|
// authenticate the brontide transport.
|
|
IdentityKey *btcec.PublicKey
|
|
|
|
// Addresses is a list of possible addresses to reach the tower.
|
|
Addresses []net.Addr
|
|
}
|
|
|
|
// AddAddress adds the given address to the tower's in-memory list of addresses.
|
|
// If the address's string is already present, the Tower will be left
|
|
// unmodified. Otherwise, the adddress is prepended to the beginning of the
|
|
// Tower's addresses, on the assumption that it is fresher than the others.
|
|
//
|
|
// NOTE: This method is NOT safe for concurrent use.
|
|
func (t *Tower) AddAddress(addr net.Addr) {
|
|
// Ensure we don't add a duplicate address.
|
|
addrStr := addr.String()
|
|
for _, existingAddr := range t.Addresses {
|
|
if existingAddr.String() == addrStr {
|
|
return
|
|
}
|
|
}
|
|
|
|
// Add this address to the front of the list, on the assumption that it
|
|
// is a fresher address and will be tried first.
|
|
t.Addresses = append([]net.Addr{addr}, t.Addresses...)
|
|
}
|
|
|
|
// LNAddrs generates a list of lnwire.NetAddress from a Tower instance's
|
|
// addresses. This can be used to have a client try multiple addresses for the
|
|
// same Tower.
|
|
//
|
|
// NOTE: This method is NOT safe for concurrent use.
|
|
func (t *Tower) LNAddrs() []*lnwire.NetAddress {
|
|
addrs := make([]*lnwire.NetAddress, 0, len(t.Addresses))
|
|
for _, addr := range t.Addresses {
|
|
addrs = append(addrs, &lnwire.NetAddress{
|
|
IdentityKey: t.IdentityKey,
|
|
Address: addr,
|
|
})
|
|
}
|
|
|
|
return addrs
|
|
}
|
|
|
|
// Encode writes the Tower to the passed io.Writer. The TowerID is not
|
|
// serialized, since it acts as the key.
|
|
func (t *Tower) Encode(w io.Writer) error {
|
|
return WriteElements(w,
|
|
t.IdentityKey,
|
|
t.Addresses,
|
|
)
|
|
}
|
|
|
|
// Decode reads a Tower from the passed io.Reader. The TowerID is meant to be
|
|
// decoded from the key.
|
|
func (t *Tower) Decode(r io.Reader) error {
|
|
return ReadElements(r,
|
|
&t.IdentityKey,
|
|
&t.Addresses,
|
|
)
|
|
}
|