Add external liquidity providers

server/internal/core/application/service.go

@@ -5,12 +5,13 @@
 	"context"
 	"encoding/hex"
 	"fmt"
+	txbuilder "github.com/ark-network/ark/internal/infrastructure/tx-builder/covenant"
 	"sync"
 	"time"
 
 	"github.com/ark-network/ark/common"
 	"github.com/ark-network/ark/common/tree"
 	"github.com/ark-network/ark/internal/core/domain"
 	"github.com/ark-network/ark/internal/core/ports"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/decred/dcrd/dcrec/secp256k1/v4"
@@ -385,41 +386,78 @@
 		return
 	}
 
-	sweptRounds, err := s.repoManager.Rounds().GetSweptRounds(ctx)
-	if err != nil {
-		changes = round.Fail(fmt.Errorf("failed to retrieve swept rounds: %s", err))
-		log.WithError(err).Warn("failed to retrieve swept rounds")
-		return
-	}
+	if round.RequiresLiquidityProvider {
+		fmt.Println("This round requires a liquidity provider.")
 
-	unsignedPoolTx, tree, connectorAddress, err := s.builder.BuildPoolTx(s.pubkey, payments, s.minRelayFee, sweptRounds)
-	if err != nil {
-		changes = round.Fail(fmt.Errorf("failed to create pool tx: %s", err))
-		log.WithError(err).Warn("failed to create pool tx")
-		return
-	}
-	log.Debugf("pool tx created for round %s", round.Id)
+		liquidityTxBuilder := txbuilder.NewLiquidityTxBuilder(s.builder)
 
-	// TODO BTC make the senders sign the tree
+		unsignedPoolTx, tree, connectorAddress, err := liquidityTxBuilder.BuildPoolTxFromLiquidityProvider(payments, s.minRelayFee, round.LiquidityProvider, s.pubkey)
+		if err != nil {
+			changes = round.Fail(fmt.Errorf("failed to create pool tx: %s", err))
+			log.WithError(err).Warn("failed to create pool tx")
+			return
+		}
+		log.Debugf("pool tx created for round %s", round.Id)
 
-	connectors, forfeitTxs, err := s.builder.BuildForfeitTxs(s.pubkey, unsignedPoolTx, payments, s.minRelayFee)
-	if err != nil {
-		changes = round.Fail(fmt.Errorf("failed to create connectors and forfeit txs: %s", err))
-		log.WithError(err).Warn("failed to create connectors and forfeit txs")
-		return
-	}
+		// TODO BTC make the senders sign the tree
 
-	log.Debugf("forfeit transactions created for round %s", round.Id)
+		connectors, forfeitTxs, err := s.builder.BuildForfeitTxs(round.LiquidityProvider.PubKey, unsignedPoolTx, payments, s.minRelayFee)
+		if err != nil {
+			changes = round.Fail(fmt.Errorf("failed to create connectors and forfeit txs: %s", err))
+			log.WithError(err).Warn("failed to create connectors and forfeit txs")
+			return
+		}
 
-	events, err := round.StartFinalization(connectorAddress, connectors, tree, unsignedPoolTx)
-	if err != nil {
-		changes = round.Fail(fmt.Errorf("failed to start finalization: %s", err))
-		log.WithError(err).Warn("failed to start finalization")
-		return
-	}
-	changes = append(changes, events...)
+		log.Debugf("forfeit transactions created for round %s", round.Id)
+
+		events, err := round.StartFinalization(connectorAddress, connectors, tree, unsignedPoolTx)
+		if err != nil {
+			changes = round.Fail(fmt.Errorf("failed to start finalization: %s", err))
+			log.WithError(err).Warn("failed to start finalization")
+			return
+		}
+		changes = append(changes, events...)
+
+		s.forfeitTxs.push(forfeitTxs)
+	} else {
+		fmt.Println("This round does not require a liquidity provider.")
+
+		sweptRounds, err := s.repoManager.Rounds().GetSweptRounds(ctx)
+		if err != nil {
+			changes = round.Fail(fmt.Errorf("failed to retrieve swept rounds: %s", err))
+			log.WithError(err).Warn("failed to retrieve swept rounds")
+			return
+		}
+
+		unsignedPoolTx, tree, connectorAddress, err := s.builder.BuildPoolTx(s.pubkey, payments, s.minRelayFee, sweptRounds)
+		if err != nil {
+			changes = round.Fail(fmt.Errorf("failed to create pool tx: %s", err))
+			log.WithError(err).Warn("failed to create pool tx")
+			return
+		}
+		log.Debugf("pool tx created for round %s", round.Id)
+
+		// TODO BTC make the senders sign the tree
 
-	s.forfeitTxs.push(forfeitTxs)
+		connectors, forfeitTxs, err := s.builder.BuildForfeitTxs(s.pubkey, unsignedPoolTx, payments, s.minRelayFee)
+		if err != nil {
+			changes = round.Fail(fmt.Errorf("failed to create connectors and forfeit txs: %s", err))
+			log.WithError(err).Warn("failed to create connectors and forfeit txs")
+			return
+		}
+
+		log.Debugf("forfeit transactions created for round %s", round.Id)
+
+		events, err := round.StartFinalization(connectorAddress, connectors, tree, unsignedPoolTx)
+		if err != nil {
+			changes = round.Fail(fmt.Errorf("failed to start finalization: %s", err))
+			log.WithError(err).Warn("failed to start finalization")
+			return
+		}
+		changes = append(changes, events...)
+
+		s.forfeitTxs.push(forfeitTxs)
+	}
 
 	log.Debugf("started finalization stage for round: %s", round.Id)
 }

server/internal/core/domain/liquidity_provider.go

@@ -0,0 +1,16 @@
+package domain
+
+import (
+	"github.com/ark-network/ark/internal/core/ports"
+	"github.com/decred/dcrd/dcrec/secp256k1/v4"
+)
+
+type LiquidityProvider struct {
+	PubKey  *secp256k1.PublicKey
+	UTXO    []ports.TxInput
+	FeeRate uint64
+}
+
+func (lp *LiquidityProvider) CheckFeeRate(minRate, maxRate uint64) bool {
+	return lp.FeeRate >= minRate && lp.FeeRate <= maxRate
+}

server/internal/core/domain/round.go

@@ -34,21 +34,23 @@ type Stage struct {
 }
 
 type Round struct {
-	Id                string
-	StartingTimestamp int64
-	EndingTimestamp   int64
-	Stage             Stage
-	Payments          map[string]Payment
-	Txid              string
-	UnsignedTx        string
-	ForfeitTxs        []string
-	CongestionTree    tree.CongestionTree
-	Connectors        []string
-	ConnectorAddress  string
-	DustAmount        uint64
-	Version           uint
-	Swept             bool // true if all the vtxos are vtxo.Swept or vtxo.Redeemed
-	changes           []RoundEvent
+	Id                        string
+	StartingTimestamp         int64
+	EndingTimestamp           int64
+	Stage                     Stage
+	Payments                  map[string]Payment
+	Txid                      string
+	UnsignedTx                string
+	ForfeitTxs                []string
+	CongestionTree            tree.CongestionTree
+	Connectors                []string
+	ConnectorAddress          string
+	DustAmount                uint64
+	Version                   uint
+	Swept                     bool // true if all the vtxos are vtxo.Swept or vtxo.Redeemed
+	RequiresLiquidityProvider bool // true if this round requires a liquidity provider
+	LiquidityProvider         *LiquidityProvider
+	changes                   []RoundEvent
 }
 
 func NewRound(dustAmount uint64) *Round {