Files
zeekay 19b49809fd Implement threshold MPC signing with CGGMP21, FROST, and LSS protocols
This commit adds complete multi-party computation (MPC) threshold signing
for multiple cryptographic protocols:

CGGMP21 (ECDSA/secp256k1):
- Key generation for Bitcoin/Ethereum/EVM chains
- Threshold signing with t-of-n security
- Recovery byte calculation for Ethereum compatibility

FROST/Taproot (EdDSA/BIP-340):
- EdDSA key generation for Solana/Sui/Polkadot
- BIP-340 compatible Schnorr signatures (64 bytes)
- CBOR serialization for TaprootConfig crypto types

LSS (Linear Secret Sharing):
- Dynamic resharing support (change participants)
- ECDSA signing with blinding protocol
- Protocol adapter for unified interface

Key fixes:
- Use MarshalBinary/UnmarshalBinary for protocol messages
- CBOR serialization for FROST TaprootConfig (not JSON)
- Correct type assertion for taproot.Signature ([]byte)
- Sorted party IDs for deterministic ordering

E2E tests pass for both ECDSA and EdDSA signing.
2026-01-24 23:41:43 -08:00

101 lines
2.8 KiB
Go

package eventconsumer
import (
"encoding/json"
"github.com/nats-io/nats.go"
"github.com/hanzoai/mpc/pkg/event"
"github.com/hanzoai/mpc/pkg/logger"
"github.com/hanzoai/mpc/pkg/messaging"
)
// Other service not listen to this subject that make loss of message
const maxDeliveriesExceededSubject = "$JS.EVENT.ADVISORY.CONSUMER.MAX_DELIVERIES.>"
type timeOutConsumer struct {
natsConn *nats.Conn
resultQueue messaging.MessageQueue
advisorySub messaging.Subscription
}
func NewTimeOutConsumer(natsConn *nats.Conn, resultQueue messaging.MessageQueue) *timeOutConsumer {
return &timeOutConsumer{
natsConn: natsConn,
resultQueue: resultQueue,
}
}
func (tc *timeOutConsumer) Run() {
logger.Info("Starting advisory consumer for max deliveries exceeded")
sub, err := tc.natsConn.Subscribe(maxDeliveriesExceededSubject, func(msg *nats.Msg) {
data := msg.Data
var advisory struct {
Stream string `json:"stream"`
StreamSeq uint64 `json:"stream_seq"`
}
err := json.Unmarshal(data, &advisory)
if err != nil {
logger.Error("Failed to unmarshal advisory message", err)
return
}
logger.Info("Received advisory message", "stream", advisory.Stream, "stream_seq", advisory.StreamSeq)
if advisory.Stream == event.SigningPublisherStream {
logger.Info("Received max deliveries exceeded advisory", "stream", advisory.Stream, "stream_seq", advisory.StreamSeq)
js, _ := tc.natsConn.JetStream()
failedMsg, err := js.GetMsg(advisory.Stream, advisory.StreamSeq)
if err != nil {
logger.Error("Failed to retrieve message", err)
return
}
data := failedMsg.Data
var signErrorResult event.SigningResultEvent
err = json.Unmarshal(data, &signErrorResult)
if err != nil {
logger.Error("Failed to unmarshal signing result event", err)
return
}
signErrorResult.ResultType = event.ResultTypeError
signErrorResult.ErrorCode = event.ErrorCodeMaxDeliveryAttempts
signErrorResult.IsTimeout = true
signErrorResult.ErrorReason = "Signing failed: maximum delivery attempts exceeded"
signErrorResultBytes, err := json.Marshal(signErrorResult)
if err != nil {
logger.Error("Failed to marshal signing result event", err)
return
}
err = tc.resultQueue.Enqueue(event.SigningResultTopic, signErrorResultBytes, &messaging.EnqueueOptions{
IdempotententKey: signErrorResult.TxID,
})
if err != nil {
logger.Error("Failed to publish signing result event", err)
return
}
logger.Info("Published signing result event for timeout", "txID", signErrorResult.TxID)
return
}
})
if err != nil {
logger.Error("Failed to subscribe to max deliveries exceeded subject", err)
return
}
tc.advisorySub = sub
}
func (tc *timeOutConsumer) Close() error {
err := tc.advisorySub.Unsubscribe()
if err != nil {
return err
}
return nil
}