watchtower/multi: use proper TowerID type

This allows serialization methods to be added with TowerID method
receivers.

watchtower/wtclient/interface.go

@@ -21,7 +21,7 @@ type DB interface {
 	CreateTower(*lnwire.NetAddress) (*wtdb.Tower, error)
 
 	// LoadTower retrieves a tower by its tower ID.
-	LoadTower(uint64) (*wtdb.Tower, error)
+	LoadTower(wtdb.TowerID) (*wtdb.Tower, error)
 
 	// NextSessionKeyIndex reserves a new session key derivation index for a
 	// particular tower id. The index is reserved for that tower until
@@ -29,7 +29,7 @@ type DB interface {
 	// point a new index for that tower can be reserved. Multiple calls to
 	// this method before CreateClientSession is invoked should return the
 	// same index.
-	NextSessionKeyIndex(uint64) (uint32, error)
+	NextSessionKeyIndex(wtdb.TowerID) (uint32, error)
 
 	// CreateClientSession saves a newly negotiated client session to the
 	// client's database. This enables the session to be used across

watchtower/wtdb/client_session.go

@@ -57,7 +57,7 @@ type ClientSession struct {
 
 	// TowerID is the unique, db-assigned identifier that references the
 	// Tower with which the session is negotiated.
-	TowerID uint64
+	TowerID TowerID
 
 	// Tower holds the pubkey and address of the watchtower.
 	//

watchtower/wtdb/tower.go

@@ -15,12 +15,31 @@ var (
 	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 uint64
+	ID TowerID
 
 	// IdentityKey is the public key of the remote node, used to
 	// authenticate the brontide transport.

watchtower/wtmock/client_db.go

@@ -20,11 +20,11 @@ type ClientDB struct {
 	mu             sync.Mutex
 	sweepPkScripts map[lnwire.ChannelID][]byte
 	activeSessions map[wtdb.SessionID]*wtdb.ClientSession
-	towerIndex     map[towerPK]uint64
-	towers         map[uint64]*wtdb.Tower
+	towerIndex     map[towerPK]wtdb.TowerID
+	towers         map[wtdb.TowerID]*wtdb.Tower
 
 	nextIndex uint32
-	indexes   map[uint64]uint32
+	indexes   map[wtdb.TowerID]uint32
 }
 
 // NewClientDB initializes a new mock ClientDB.
@@ -32,9 +32,9 @@ func NewClientDB() *ClientDB {
 	return &ClientDB{
 		sweepPkScripts: make(map[lnwire.ChannelID][]byte),
 		activeSessions: make(map[wtdb.SessionID]*wtdb.ClientSession),
-		towerIndex:     make(map[towerPK]uint64),
-		towers:         make(map[uint64]*wtdb.Tower),
-		indexes:        make(map[uint64]uint32),
+		towerIndex:     make(map[towerPK]wtdb.TowerID),
+		towers:         make(map[wtdb.TowerID]*wtdb.Tower),
+		indexes:        make(map[wtdb.TowerID]uint32),
 	}
 }
 
@@ -54,9 +54,9 @@ func (m *ClientDB) CreateTower(lnAddr *lnwire.NetAddress) (*wtdb.Tower, error) {
 		tower = m.towers[towerID]
 		tower.AddAddress(lnAddr.Address)
 	} else {
-		towerID = atomic.AddUint64(&m.nextTowerID, 1)
+		towerID = wtdb.TowerID(atomic.AddUint64(&m.nextTowerID, 1))
 		tower = &wtdb.Tower{
-			ID:          towerID,
+			ID:          wtdb.TowerID(towerID),
 			IdentityKey: lnAddr.IdentityKey,
 			Addresses:   []net.Addr{lnAddr.Address},
 		}
@@ -69,7 +69,7 @@ func (m *ClientDB) CreateTower(lnAddr *lnwire.NetAddress) (*wtdb.Tower, error) {
 }
 
 // LoadTower retrieves a tower by its tower ID.
-func (m *ClientDB) LoadTower(towerID uint64) (*wtdb.Tower, error) {
+func (m *ClientDB) LoadTower(towerID wtdb.TowerID) (*wtdb.Tower, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
@@ -141,7 +141,7 @@ func (m *ClientDB) CreateClientSession(session *wtdb.ClientSession) error {
 // CreateClientSession is invoked for that tower and index, at which point a new
 // index for that tower can be reserved. Multiple calls to this method before
 // CreateClientSession is invoked should return the same index.
-func (m *ClientDB) NextSessionKeyIndex(towerID uint64) (uint32, error) {
+func (m *ClientDB) NextSessionKeyIndex(towerID wtdb.TowerID) (uint32, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()