Make the round participants sign the vtxo tree (#271)

* [proto] add APIs to send and receive musig2 signing data

* [common] add serialization functions for nonces and signatures

* [application] implements tree signing

* fix: remove old debug logs

* [proto] cleaning

* [common] fix musig2.go

* [application] fixes and logs

* [interface] fix: stop forwarding 2 times the events

* [client] add musig2 support + sign the tree when joining a round

* [interface] add new APIs into permissions.go

* [application][proto] rework PingResponse (return all events type)

* [common] split SetKeys into 2 distinct methods

* [client] fixes according to musig2.go changes

* [sdk] support tree signing + new PingResponse

* [sdk] fixes

* [application] revert event channel type

* [application] use domain.RoundEvent as lastEvent type

* [application] remove IsCovenantLess

* comments

* [application] revert roundAborted changes

* [interface] remove bitcointree dependencie

server/internal/core/application/utils.go

@@ -10,6 +10,7 @@ import (
 	"github.com/ark-network/ark/common/tree"
 	"github.com/ark-network/ark/server/internal/core/domain"
 	"github.com/ark-network/ark/server/internal/core/ports"
+	"github.com/decred/dcrd/dcrec/secp256k1/v4"
 	"github.com/sirupsen/logrus"
 )
 
@@ -20,8 +21,9 @@ type timedPayment struct {
 }
 
 type paymentsMap struct {
-	lock     *sync.RWMutex
-	payments map[string]*timedPayment
+	lock          *sync.RWMutex
+	payments      map[string]*timedPayment
+	ephemeralKeys map[string]*secp256k1.PublicKey
 }
 
 func newPaymentsMap(payments []domain.Payment) *paymentsMap {
@@ -30,7 +32,7 @@ func newPaymentsMap(payments []domain.Payment) *paymentsMap {
 		paymentsById[p.Id] = &timedPayment{p, time.Now(), time.Time{}}
 	}
 	lock := &sync.RWMutex{}
-	return &paymentsMap{lock, paymentsById}
+	return &paymentsMap{lock, paymentsById, make(map[string]*secp256k1.PublicKey)}
 }
 
 func (m *paymentsMap) len() int64 {
@@ -46,6 +48,18 @@ func (m *paymentsMap) len() int64 {
 	return count
 }
 
+func (m *paymentsMap) delete(id string) error {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	if _, ok := m.payments[id]; !ok {
+		return errPaymentNotFound{id}
+	}
+
+	delete(m.payments, id)
+	return nil
+}
+
 func (m *paymentsMap) push(payment domain.Payment) error {
 	m.lock.Lock()
 	defer m.lock.Unlock()
@@ -58,7 +72,19 @@ func (m *paymentsMap) push(payment domain.Payment) error {
 	return nil
 }
 
-func (m *paymentsMap) pop(num int64) []domain.Payment {
+func (m *paymentsMap) pushEphemeralKey(paymentId string, pubkey *secp256k1.PublicKey) error {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	if _, ok := m.payments[paymentId]; !ok {
+		return fmt.Errorf("payment %s not found, cannot register signing ephemeral public key", paymentId)
+	}
+
+	m.ephemeralKeys[paymentId] = pubkey
+	return nil
+}
+
+func (m *paymentsMap) pop(num int64) ([]domain.Payment, []*secp256k1.PublicKey) {
 	m.lock.Lock()
 	defer m.lock.Unlock()
 
@@ -83,11 +109,16 @@ func (m *paymentsMap) pop(num int64) []domain.Payment {
 	}
 
 	payments := make([]domain.Payment, 0, num)
+	cosigners := make([]*secp256k1.PublicKey, 0, num)
 	for _, p := range paymentsByTime[:num] {
 		payments = append(payments, p.Payment)
+		if pubkey, ok := m.ephemeralKeys[p.Payment.Id]; ok {
+			cosigners = append(cosigners, pubkey)
+			delete(m.ephemeralKeys, p.Payment.Id)
+		}
 		delete(m.payments, p.Id)
 	}
-	return payments
+	return payments, cosigners
 }
 
 func (m *paymentsMap) update(payment domain.Payment) error {