extracted witness and producer logic

Author: hn275

modules/oracle/price/api/coingecko.go

@@ -12,6 +12,8 @@ const (
 	pageLimit = 250
 )
 
+var _ PriceQuery = &CoinGecko{}
+
 type CoinGecko struct {
 	baseUrl  string
 	apiKey   string

modules/oracle/price/api/coinmarketcap.go

@@ -15,7 +15,7 @@ type CoinMarketCap struct {
 	currency string
 }
 
-// var _ PriceQuery = &CoinMarketCap{}
+var _ PriceQuery = &CoinMarketCap{}
 
 // Source implements PriceQuery
 func (c *CoinMarketCap) Source() string {

modules/oracle/price/handle_block_tick.go

@@ -2,24 +2,12 @@ package price
 
 import (
 	"context"
-	"encoding/base64"
-	"encoding/hex"
 	"errors"
-	"fmt"
-	"log/slog"
 	"math"
-	"slices"
 	"strings"
 	"time"
-	"vsc-node/lib/dids"
-	"vsc-node/modules/common"
-	"vsc-node/modules/db/vsc/elections"
 	"vsc-node/modules/oracle/p2p"
 	"vsc-node/modules/oracle/price/api"
-	stateEngine "vsc-node/modules/state-processing"
-	transactionpool "vsc-node/modules/transaction-pool"
-
-	blsu "github.com/protolambda/bls12-381-util"
 )
 
 type CollectedPricePoint struct {
@@ -81,7 +69,6 @@ func (o *PriceOracle) HandleBlockTick(
 		}
 	}
 
-	// make transaction
 	var handler interface {
 		handle(map[string]api.PricePoint) error
 	}
@@ -167,284 +154,4 @@ func (o *PriceOracle) collectAveragePricePoints(
 	}
 }
 
-// block producer
-type Producer struct {
-	p2p.OracleP2PSpec
-	ctx              context.Context
-	logger           *slog.Logger
-	blockTickSignal  p2p.BlockTickSignal
-	signatureChannel *SignatureResponseChannel
-}
-
-func (p *Producer) handle(medianPriceMap map[string]api.PricePoint) error {
-	p.logger.Debug("making block", "median-prices", medianPriceMap)
-
-	tx, err := makeTx(medianPriceMap)
-	if err != nil {
-		return fmt.Errorf("failed to create tx: %w", err)
-	}
-
-	// broadcast signature request
-	sigRequestMsg := SignatureRequestMessage{
-		SigHash:     tx.String(),
-		MedianPrice: medianPriceMap,
-	}
-
-	msg, err := makePriceOracleMessage(signatureRequestCode, &sigRequestMsg)
-	if err != nil {
-		return fmt.Errorf("failed to make message: %w", err)
-	}
-
-	if err := p.Broadcast(p2p.MsgPriceOracle, msg); err != nil {
-		return fmt.Errorf("failed to broadcast signature request: %w", err)
-	}
-	p.logger.Debug(
-		"signature request broadcasted",
-		"sig-hash", sigRequestMsg.SigHash,
-		"median-price", sigRequestMsg.MedianPrice,
-	)
-
-	// make bls circuit
-	txCid := tx.Cid()
-
-	witnessDIDs := make([]dids.Member, len(p.blockTickSignal.ElectedMembers))
-	for i := range p.blockTickSignal.ElectedMembers {
-		witnessDIDs[i] = dids.BlsDID(p.blockTickSignal.ElectedMembers[i].Key)
-	}
-
-	circuit, err := dids.NewBlsCircuitGenerator(witnessDIDs).Generate(txCid)
-	if err != nil {
-		return fmt.Errorf("failed to generate bls circuit: %w", err)
-	}
-
-	// collect and verify signatures with bls circuit
-
-	ctx, cancel := context.WithTimeout(p.ctx, 15*time.Second)
-	defer cancel()
-
-	if err := p.collectSignature(ctx, circuit); err != nil {
-		return fmt.Errorf("failed to collect signatures: %w", err)
-	}
-
-	// make transaction + submit to contract
-	blsCircuit, err := circuit.Finalize()
-	if err != nil {
-		return fmt.Errorf("failed to finalize circuit: %w", err)
-	}
-
-	serializedCircuit, err := blsCircuit.Serialize()
-	if err != nil {
-		return fmt.Errorf("failed to finalize circuit: %w", err)
-	}
-
-	sigPackage := stateEngine.TransactionSig{
-		Type: "vsc-sig",
-		Sigs: []common.Sig{{
-			Algo: "bls-agg",
-			Sig:  serializedCircuit.Signature,
-			Bv:   serializedCircuit.BitVector,
-			Kid:  "",
-		}},
-	}
-
-	sigBytes, err := common.EncodeDagCbor(sigPackage)
-	if err != nil {
-		return fmt.Errorf("failed encode DagCbor: %w", err)
-	}
-
-	// submit contract
-	vscTx := transactionpool.SerializedVSCTransaction{
-		Tx:  txCid.Bytes(),
-		Sig: sigBytes,
-	}
-
-	if err := p.submitToContract(vscTx); err != nil {
-		return fmt.Errorf("failed to submit to contract: %w", err)
-	}
-
-	return nil
-}
-
-func (p *Producer) collectSignature(
-	ctx context.Context,
-	circuit dids.PartialBlsCircuit,
-) error {
-	signatureThreshold := (p.blockTickSignal.TotalElectionWeight * 2) / 3
-	signedWeight := uint64(0)
-
-	p.logger.Debug(
-		"collecting signatures",
-		"signature-threshold", signatureThreshold,
-	)
-
-	receiver := p.signatureChannel.Open()
-	defer p.signatureChannel.Close()
-
-	for signedWeight < signatureThreshold {
-		select {
-		case <-ctx.Done():
-			if err := ctx.Err(); err != nil {
-				return fmt.Errorf("context error: %w", err)
-			} else {
-				return errors.New("signature collection timed out")
-			}
-
-		case msg := <-receiver:
-			memberIndex := slices.IndexFunc(
-				p.blockTickSignal.ElectedMembers,
-				func(e elections.ElectionMember) bool {
-					return e.Account == msg.Signer
-				},
-			)
-
-			if memberIndex == -1 {
-				p.logger.Debug(
-					"invalid witness signature, dropping.",
-					"signer", msg.Signer,
-				)
-				continue
-			}
-
-			member := &p.blockTickSignal.ElectedMembers[memberIndex]
-			memberDID := dids.BlsDID(member.Key)
-
-			added, err := circuit.AddAndVerify(memberDID, msg.Signature)
-			if err != nil {
-				p.logger.Error("failed to verify signature", "err", err)
-				continue
-			}
-
-			if !added {
-				p.logger.Debug("invalid signature, signature not added to circuit")
-				continue
-			}
-
-			signedWeight += p.blockTickSignal.WeightMap[memberIndex]
-			p.logger.Debug(
-				"received witness signature, appending to witnessSigned",
-				"signer", member.Account, "signature", msg.Signature,
-			)
-		}
-	}
-
-	return nil
-}
-
-// TODO: implement this function
-func (p *Producer) submitToContract(transactionpool.SerializedVSCTransaction) error {
-	p.logger.Error("submit to contract not implemented")
-	return nil
-}
-
 // witness
-type Witness struct {
-	p2p.OracleP2PSpec
-	ctx                     context.Context
-	logger                  *slog.Logger
-	blockTickSignal         p2p.BlockTickSignal
-	signatureRequestChannel *SignatureRequestChannel
-	identity                common.IdentityConfig
-}
-
-func (w *Witness) handle(medianPriceMap map[string]api.PricePoint) error {
-	w.logger.Debug(
-		"witness median prices",
-		"median-prices", medianPriceMap,
-	)
-
-	//  receiving median price
-	receiver := w.signatureRequestChannel.Open()
-	defer w.signatureRequestChannel.Close()
-
-	ctx, cancel := context.WithTimeout(w.ctx, 30*time.Second)
-	defer cancel()
-
-	var signatureRequest SignatureRequestMessage
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-
-	case signatureRequest = <-receiver:
-		w.logger.Debug("signature request received")
-	}
-
-	w.logger.Debug("signature request received",
-		"median-price", signatureRequest.MedianPrice,
-		"signature-hash", signatureRequest.SigHash,
-	)
-
-	// compare broadcasted vs local median price
-	for sym, pricePoint := range signatureRequest.MedianPrice {
-		localPricePoint, ok := medianPriceMap[sym]
-		if !ok {
-			return fmt.Errorf("failed to verify median price point for ticker %s", sym)
-		}
-
-		priceOk := floatEqual(pricePoint.Price, localPricePoint.Price)
-		if !priceOk {
-			return fmt.Errorf("failed to verify median price for ticker %s", sym)
-		}
-
-		volumeOk := floatEqual(pricePoint.Volume, localPricePoint.Volume)
-		if !volumeOk {
-			return fmt.Errorf("failed to verify median volume for ticker %s", sym)
-		}
-	}
-
-	w.logger.Debug("median price verified", "broadcasted-median-price", signatureRequest.MedianPrice)
-
-	// make tx + verify incoming sig hash
-	tx, err := makeTx(signatureRequest.MedianPrice)
-	if err != nil {
-		return fmt.Errorf("failed to create transaction: %w", err)
-	}
-
-	txCid := tx.Cid()
-	sigHashOk := signatureRequest.SigHash == txCid.String()
-	if !sigHashOk {
-		return fmt.Errorf("invalid signature hash")
-	}
-
-	w.logger.Debug("signature hash verified", "sig-hash", signatureRequest.SigHash)
-
-	// sign data
-	blsKeyDecoded, err := hex.DecodeString(w.identity.Get().BlsPrivKeySeed)
-	if err != nil {
-		return fmt.Errorf("failed to decode BLS private key seed: %w", err)
-	}
-
-	if len(blsKeyDecoded) != 32 {
-		return errors.New("bls priv seed must be 32 bytes")
-	}
-
-	var blsKeyBuf [32]byte
-	copy(blsKeyBuf[:], blsKeyDecoded)
-
-	blsSecretKey := &blsu.SecretKey{}
-	if err := blsSecretKey.Deserialize(&blsKeyBuf); err != nil {
-		return fmt.Errorf("failed to deserialize bls priv key: %w", err)
-	}
-
-	sigBytes := blsu.Sign(blsSecretKey, txCid.Bytes()).Serialize()
-
-	// broadcast signature
-	signatureResponse := &SignatureResponseMessage{
-		Signer:    w.identity.Get().HiveUsername,
-		Signature: base64.RawURLEncoding.EncodeToString(sigBytes[:]),
-	}
-
-	msg, err := makePriceOracleMessage(signatureResponseCode, signatureResponse)
-	if err != nil {
-		return fmt.Errorf("failed to make price oracle message: %w", err)
-	}
-
-	if err := w.Broadcast(p2p.MsgPriceOracle, msg); err != nil {
-		return fmt.Errorf("failed to broadcast signature response: %w", err)
-	}
-	w.logger.Debug(
-		"signature response broadcasted",
-		"signature", signatureResponse.Signature,
-	)
-
-	return nil
-}

modules/oracle/price/price_oracle.go

@@ -17,9 +17,6 @@ import (
 var (
 	_ p2p.MessageHandler = &PriceOracle{}
 	_ aggregate.Plugin   = &PriceOracle{}
-
-	_ api.PriceQuery = &api.CoinGecko{}
-	_ api.PriceQuery = &api.CoinMarketCap{}
 )
 
 type PriceOracle struct {