staticaddr: deposit manager and fsm

Author: hieblmi

staticaddr/manager.go renamed to staticaddr/address/manager.go

@@ -1,4 +1,4 @@
-package staticaddr
+package address
 
 import (
 	"bytes"
@@ -12,6 +12,7 @@ import (
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/loop"
+	"github.com/lightninglabs/loop/staticaddr"
 	"github.com/lightninglabs/loop/staticaddr/script"
 	"github.com/lightninglabs/loop/swap"
 	staticaddressrpc "github.com/lightninglabs/loop/swapserverrpc"
@@ -31,7 +32,7 @@ type ManagerConfig struct {
 
 	// Store is the database store that is used to store static address
 	// related records.
-	Store AddressStore
+	Store Store
 
 	// WalletKit is the wallet client that is used to derive new keys from
 	// lnd's wallet.
@@ -46,31 +47,20 @@ type ManagerConfig struct {
 type Manager struct {
 	cfg *ManagerConfig
 
-	initChan chan struct{}
-
 	sync.Mutex
 }
 
-// NewAddressManager creates a new address manager.
-func NewAddressManager(cfg *ManagerConfig) *Manager {
+// NewManager creates a new address manager.
+func NewManager(cfg *ManagerConfig) *Manager {
 	return &Manager{
-		cfg:      cfg,
-		initChan: make(chan struct{}),
+		cfg: cfg,
 	}
 }
 
 // Run runs the address manager.
 func (m *Manager) Run(ctx context.Context) error {
-	log.Debugf("Starting address manager.")
-	defer log.Debugf("Address manager stopped.")
-
-	// Communicate to the caller that the address manager has completed its
-	// initialization.
-	close(m.initChan)
-
 	<-ctx.Done()
-
-	return nil
+	return ctx.Err()
 }
 
 // NewAddress starts a new address creation flow.
@@ -113,7 +103,7 @@ func (m *Manager) NewAddress(ctx context.Context) (*btcutil.AddressTaproot,
 
 	// Send our clientPubKey to the server and wait for the server to
 	// respond with he serverPubKey and the static address CSV expiry.
-	protocolVersion := CurrentRPCProtocolVersion()
+	protocolVersion := staticaddr.CurrentRPCProtocolVersion()
 	resp, err := m.cfg.AddressClient.ServerNewAddress(
 		ctx, &staticaddressrpc.ServerNewAddressRequest{
 			ProtocolVersion: protocolVersion,
@@ -146,7 +136,7 @@ func (m *Manager) NewAddress(ctx context.Context) (*btcutil.AddressTaproot,
 
 	// Create the static address from the parameters the server provided and
 	// store all parameters in the database.
-	addrParams := &AddressParameters{
+	addrParams := &Parameters{
 		ClientPubkey: clientPubKey.PubKey,
 		ServerPubkey: serverPubKey,
 		PkScript:     pkScript,
@@ -155,7 +145,9 @@ func (m *Manager) NewAddress(ctx context.Context) (*btcutil.AddressTaproot,
 			Family: clientPubKey.Family,
 			Index:  clientPubKey.Index,
 		},
-		ProtocolVersion: AddressProtocolVersion(protocolVersion),
+		ProtocolVersion: staticaddr.AddressProtocolVersion(
+			protocolVersion,
+		),
 	}
 	err = m.cfg.Store.CreateStaticAddress(ctx, addrParams)
 	if err != nil {
@@ -197,12 +189,6 @@ func (m *Manager) getTaprootAddress(clientPubkey,
 	)
 }
 
-// WaitInitComplete waits until the address manager has completed its setup.
-func (m *Manager) WaitInitComplete() {
-	defer log.Debugf("Address manager initiation complete.")
-	<-m.initChan
-}
-
 // ListUnspentRaw returns a list of utxos at the static address.
 func (m *Manager) ListUnspentRaw(ctx context.Context, minConfs,
 	maxConfs int32) (*btcutil.AddressTaproot, []*lnwallet.Utxo, error) {
@@ -213,7 +199,7 @@ func (m *Manager) ListUnspentRaw(ctx context.Context, minConfs,
 		return nil, nil, err
 
 	case len(addresses) == 0:
-		return nil, nil, fmt.Errorf("no address found")
+		return nil, nil, nil
 
 	case len(addresses) > 1:
 		return nil, nil, fmt.Errorf("more than one address found")
@@ -249,3 +235,52 @@ func (m *Manager) ListUnspentRaw(ctx context.Context, minConfs,
 
 	return taprootAddress, filteredUtxos, nil
 }
+
+// GetStaticAddressParameters returns the parameters of the static address.
+func (m *Manager) GetStaticAddressParameters(ctx context.Context) (*Parameters,
+	error) {
+
+	params, err := m.cfg.Store.GetAllStaticAddresses(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(params) == 0 {
+		return nil, fmt.Errorf("no static address parameters found")
+	}
+
+	return params[0], nil
+}
+
+// GetStaticAddress returns a taproot address for the given client and server
+// public keys and expiry.
+func (m *Manager) GetStaticAddress(ctx context.Context) (*script.StaticAddress,
+	error) {
+
+	params, err := m.GetStaticAddressParameters(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	address, err := script.NewStaticAddress(
+		input.MuSig2Version100RC2, int64(params.Expiry),
+		params.ClientPubkey, params.ServerPubkey,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return address, nil
+}
+
+// ListUnspent returns a list of utxos at the static address.
+func (m *Manager) ListUnspent(ctx context.Context, minConfs,
+	maxConfs int32) ([]*lnwallet.Utxo, error) {
+
+	_, utxos, err := m.ListUnspentRaw(ctx, minConfs, maxConfs)
+	if err != nil {
+		return nil, err
+	}
+
+	return utxos, nil
+}

staticaddr/deposit/actions.go

@@ -0,0 +1,148 @@
+package deposit
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightninglabs/lndclient"
+	"github.com/lightninglabs/loop/fsm"
+	"github.com/lightninglabs/loop/staticaddr/script"
+)
+
+const (
+	defaultConfTarget = 3
+)
+
+// PublishDepositExpirySweepAction creates and publishes the timeout transaction
+// that spends the deposit from the static address timeout leaf to the
+// predefined timeout sweep pkscript.
+func (f *FSM) PublishDepositExpirySweepAction(_ fsm.EventContext) fsm.EventType {
+	msgTx := wire.NewMsgTx(2)
+
+	params, err := f.cfg.AddressManager.GetStaticAddressParameters(f.ctx)
+	if err != nil {
+		return fsm.OnError
+	}
+
+	// Add the deposit outpoint as input to the transaction.
+	msgTx.AddTxIn(&wire.TxIn{
+		PreviousOutPoint: f.deposit.OutPoint,
+		Sequence:         params.Expiry,
+		SignatureScript:  nil,
+	})
+
+	// Estimate the fee rate of an expiry spend transaction.
+	feeRateEstimator, err := f.cfg.WalletKit.EstimateFeeRate(
+		f.ctx, defaultConfTarget,
+	)
+	if err != nil {
+		return f.HandleError(fmt.Errorf("timeout sweep fee "+
+			"estimation failed: %v", err))
+	}
+
+	weight := script.ExpirySpendWeight()
+
+	fee := feeRateEstimator.FeeForWeight(weight)
+
+	// We cap the fee at 20% of the deposit value.
+	if fee > f.deposit.Value/5 {
+		return f.HandleError(errors.New("fee is greater than 20% of " +
+			"the deposit value"))
+	}
+
+	output := &wire.TxOut{
+		Value:    int64(f.deposit.Value - fee),
+		PkScript: f.deposit.TimeOutSweepPkScript,
+	}
+	msgTx.AddTxOut(output)
+
+	txOut := &wire.TxOut{
+		Value:    int64(f.deposit.Value),
+		PkScript: params.PkScript,
+	}
+
+	prevOut := []*wire.TxOut{txOut}
+
+	signDesc, err := f.SignDescriptor()
+	if err != nil {
+		return f.HandleError(err)
+	}
+
+	rawSigs, err := f.cfg.Signer.SignOutputRaw(
+		f.ctx, msgTx, []*lndclient.SignDescriptor{signDesc}, prevOut,
+	)
+	if err != nil {
+		return f.HandleError(err)
+	}
+
+	address, err := f.cfg.AddressManager.GetStaticAddress(f.ctx)
+	if err != nil {
+		return f.HandleError(err)
+	}
+
+	sig := rawSigs[0]
+	msgTx.TxIn[0].Witness, err = address.GenTimeoutWitness(sig)
+	if err != nil {
+		return f.HandleError(err)
+	}
+
+	txLabel := fmt.Sprintf("timeout sweep for deposit %v",
+		f.deposit.OutPoint)
+
+	err = f.cfg.WalletKit.PublishTransaction(f.ctx, msgTx, txLabel)
+	if err != nil {
+		if !strings.Contains(err.Error(), "output already spent") {
+			log.Errorf("%v: %v", txLabel, err)
+			f.LastActionError = err
+			return fsm.OnError
+		}
+	} else {
+		f.Debugf("published timeout sweep with txid: %v",
+			msgTx.TxHash())
+	}
+
+	return OnExpiryPublished
+}
+
+// WaitForExpirySweepAction waits for a sufficient number of confirmations
+// before a timeout sweep is considered successful.
+func (f *FSM) WaitForExpirySweepAction(_ fsm.EventContext) fsm.EventType {
+	spendChan, errSpendChan, err := f.cfg.ChainNotifier.RegisterConfirmationsNtfn( //nolint:lll
+		f.ctx, nil, f.deposit.TimeOutSweepPkScript, defaultConfTarget,
+		int32(f.deposit.ConfirmationHeight),
+	)
+	if err != nil {
+		return f.HandleError(err)
+	}
+
+	select {
+	case err := <-errSpendChan:
+		log.Debugf("error while sweeping expired deposit: %v", err)
+		return fsm.OnError
+
+	case confirmedTx := <-spendChan:
+		f.deposit.ExpirySweepTxid = confirmedTx.Tx.TxHash()
+		return OnExpirySwept
+
+	case <-f.ctx.Done():
+		return fsm.OnError
+	}
+}
+
+// SweptExpiredDepositAction is the final action of the FSM. It signals to the
+// manager that the deposit has been swept and the FSM can be removed. It also
+// ends the state machine main loop by cancelling its context.
+func (f *FSM) SweptExpiredDepositAction(_ fsm.EventContext) fsm.EventType {
+	select {
+	case <-f.ctx.Done():
+		return fsm.OnError
+
+	default:
+		f.finalizedDepositChan <- f.deposit.OutPoint
+		f.ctx.Done()
+	}
+
+	return fsm.NoOp
+}

staticaddr/deposit/deposit.go

@@ -0,0 +1,74 @@
+package deposit
+
+import (
+	"crypto/rand"
+	"fmt"
+
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightninglabs/loop/fsm"
+)
+
+// ID is a unique identifier for a deposit.
+type ID [IdLength]byte
+
+// FromByteSlice creates a deposit id from a byte slice.
+func (r *ID) FromByteSlice(b []byte) error {
+	if len(b) != IdLength {
+		return fmt.Errorf("deposit id must be 32 bytes, got %d, %x",
+			len(b), b)
+	}
+
+	copy(r[:], b)
+
+	return nil
+}
+
+// Deposit bundles an utxo at a static address together with manager-relevant
+// data.
+type Deposit struct {
+	// ID is the unique identifier of the deposit.
+	ID ID
+
+	// State is the current state of the deposit.
+	State fsm.StateType
+
+	// The outpoint of the deposit.
+	wire.OutPoint
+
+	// Value is the amount of the deposit.
+	Value btcutil.Amount
+
+	// ConfirmationHeight is the absolute height at which the deposit was
+	// first confirmed.
+	ConfirmationHeight int64
+
+	// TimeOutSweepPkScript is the pk script that is used to sweep the
+	// deposit to after it is expired.
+	TimeOutSweepPkScript []byte
+
+	// ExpirySweepTxid is the transaction id of the expiry sweep.
+	ExpirySweepTxid chainhash.Hash
+}
+
+// IsInPendingState returns true if the deposit is pending.
+func (d *Deposit) IsInPendingState() bool {
+	return !d.IsInFinalState()
+}
+
+// IsInFinalState returns true if the deposit is final.
+func (d *Deposit) IsInFinalState() bool {
+	return d.State == Expired || d.State == Failed
+}
+
+func (d *Deposit) isExpired(currentHeight, expiry uint32) bool {
+	return currentHeight >= uint32(d.ConfirmationHeight)+expiry
+}
+
+// GetRandomDepositID generates a random deposit ID.
+func GetRandomDepositID() (ID, error) {
+	var id ID
+	_, err := rand.Read(id[:])
+	return id, err
+}