staticaddr: serialize address creation with a channel

Author: hieblmi

staticaddr/address/manager.go

@@ -54,19 +54,36 @@ type Manager struct {
 	cfg *ManagerConfig
 
 	currentHeight atomic.Int32
+
+	// request is the internal channel over which address requests are sent
+	// to the Run loop for serialized processing.
+	requests chan request
+}
+
+type request struct {
+	ctx      context.Context
+	respChan chan response
+}
+
+type response struct {
+	addr   *btcutil.AddressTaproot
+	expiry int64
+	err    error
 }
 
 // NewManager creates a new address manager.
 func NewManager(cfg *ManagerConfig, currentHeight int32) *Manager {
 	m := &Manager{
-		cfg: cfg,
+		cfg:      cfg,
+		requests: make(chan request),
 	}
 	m.currentHeight.Store(currentHeight)
 
 	return m
 }
 
-// Run runs the address manager.
+// Run runs the address manager. It keeps track of the current block height and
+// creates new static addresses as needed.
 func (m *Manager) Run(ctx context.Context, initChan chan struct{}) error {
 	newBlockChan, newBlockErrChan, err :=
 		m.cfg.ChainNotifier.RegisterBlockEpochNtfn(ctx)
@@ -87,6 +104,21 @@ func (m *Manager) Run(ctx context.Context, initChan chan struct{}) error {
 		case err = <-newBlockErrChan:
 			return err
 
+		case req := <-m.requests:
+			go func(r request) {
+				addr, expiry, e := m.newAddress(r.ctx)
+				resp := response{
+					addr:   addr,
+					expiry: expiry,
+					err:    e,
+				}
+				select {
+				case r.respChan <- resp:
+
+				case <-r.ctx.Done():
+				}
+			}(req)
+
 		case <-ctx.Done():
 			// Signal subroutines that the manager is exiting.
 			return ctx.Err()
@@ -95,10 +127,40 @@ func (m *Manager) Run(ctx context.Context, initChan chan struct{}) error {
 }
 
 // NewAddress creates a new static address with the server or returns an
-// existing one.
+// existing one. It now sends a request to the manager's Run loop which
+// executes the actual address creation logic.
 func (m *Manager) NewAddress(ctx context.Context) (*btcutil.AddressTaproot,
 	int64, error) {
 
+	respChan := make(chan response, 1)
+	req := request{
+		ctx:      ctx,
+		respChan: respChan,
+	}
+
+	// Send the new address request to the manager run loop.
+	select {
+	case m.requests <- req:
+
+	case <-ctx.Done():
+		return nil, 0, ctx.Err()
+	}
+
+	// Wait for the response from the manager run loop.
+	select {
+	case resp := <-respChan:
+		return resp.addr, resp.expiry, resp.err
+
+	case <-ctx.Done():
+		return nil, 0, ctx.Err()
+	}
+}
+
+// newAddress contains the body of the former NewAddress method and performs the
+// actual address creation/lookup according to the requested type.
+func (m *Manager) newAddress(ctx context.Context) (*btcutil.AddressTaproot,
+	int64, error) {
+
 	// If there's already a static address in the database, we can return
 	// it.
 	m.Lock()