revert minogrpc

dkg/pedersen/dkgcli/dkgcli.go

@@ -6,10 +6,10 @@ import (
 	"os"
 
 	"go.dedis.ch/dela/cli/node"
-	"go.dedis.ch/dela/mino/minows/controller"
 
 	db "go.dedis.ch/dela/core/store/kv/controller"
 	dkg "go.dedis.ch/dela/dkg/pedersen/controller"
+	mino "go.dedis.ch/dela/mino/minogrpc/controller"
 )
 
 func main() {
@@ -34,7 +34,7 @@ func runWithCfg(args []string, cfg config) error {
 		cfg.Channel,
 		cfg.Writer,
 		db.NewController(),
-		controller.NewController(),
+		mino.NewController(),
 		dkg.NewMinimal(),
 	)
 

dkg/pedersen/pedersen_test.go

@@ -4,10 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	ma "github.com/multiformats/go-multiaddr"
 	"go.dedis.ch/dela/mino/minoch"
-	"go.dedis.ch/dela/mino/minows"
-	minokey "go.dedis.ch/dela/mino/minows/key"
 	"go.dedis.ch/dela/testing/fake"
 	"go.dedis.ch/kyber/v3/suites"
 	"go.dedis.ch/kyber/v3/util/key"
@@ -21,6 +18,8 @@ import (
 	"go.dedis.ch/dela/dkg"
 	"go.dedis.ch/dela/dkg/pedersen/types"
 	"go.dedis.ch/dela/mino"
+	"go.dedis.ch/dela/mino/minogrpc"
+	"go.dedis.ch/dela/mino/router/tree"
 	"go.dedis.ch/kyber/v3"
 )
 
@@ -187,30 +186,27 @@ func TestPedersen_Scenario(t *testing.T) {
 	dkgs := make([]dkg.DKG, n)
 	addrs := make([]mino.Address, n)
 
-	listen, err := ma.NewMultiaddr("/ip4/0.0.0.0/tcp/0")
-	require.NoError(t, err)
-
-	manager := minows.NewManager()
 	for i := 0; i < n; i++ {
-		k, err := minokey.NewKey(nil)
-		require.NoError(t, err)
+		addr := minogrpc.ParseAddress("127.0.0.1", 0)
 
-		m, err := minows.NewMinows(manager, listen, nil, k)
+		m, err := minogrpc.NewMinogrpc(addr, nil, tree.NewRouter(minogrpc.NewAddressFactory()))
 		require.NoError(t, err)
 
+		defer m.GracefulStop()
+
 		minos[i] = m
 		addrs[i] = m.GetAddress()
 	}
 
 	pubkeys := make([]kyber.Point, len(minos))
 
 	for i, mi := range minos {
-		// for _, m := range minos {
-		// 	mi.(*minows).GetCertificateStore().Store(m.GetAddress(),
-		// 		m.(*minows).GetCertificateChain())
-		// }
+		for _, m := range minos {
+			mi.(*minogrpc.Minogrpc).GetCertificateStore().Store(m.GetAddress(),
+				m.(*minogrpc.Minogrpc).GetCertificateChain())
+		}
 
-		d, pubkey := NewPedersen(mi.(*minows.Minows))
+		d, pubkey := NewPedersen(mi.(*minogrpc.Minogrpc))
 
 		dkgs[i] = d
 		pubkeys[i] = pubkey
@@ -227,7 +223,7 @@ func TestPedersen_Scenario(t *testing.T) {
 	// trying to call a decrypt/encrypt before a setup
 	message := []byte("Hello world")
 
-	_, _, err = actors[0].Encrypt(message)
+	_, _, err := actors[0].Encrypt(message)
 	require.EqualError(t, err, "you must first initialize DKG. Did you call setup() first?")
 	_, err = actors[0].Decrypt(nil, nil)
 	require.EqualError(t, err, "you must first initialize DKG. Did you call setup() first?")

dkg/pedersen/resharing_test.go

@@ -6,10 +6,14 @@ import (
 
 	"github.com/stretchr/testify/require"
 
+	"go.dedis.ch/dela/mino/minogrpc"
+	"go.dedis.ch/dela/mino/router/tree"
+
 	"go.dedis.ch/dela/dkg"
 
 	"go.dedis.ch/dela/mino"
 	"go.dedis.ch/dela/mino/minoch"
+
 	"go.dedis.ch/kyber/v3"
 )
 
@@ -153,8 +157,8 @@ func TestResharing_minoch(t *testing.T) {
 
 // This test creates a dkg committee then creates another committee (that can
 // share some nodes with the old committee) and then redistributes the secret to
-// the new committee. Using minows as the underlying network
-func IgnoreTestResharing_minogrpc(t *testing.T) {
+// the new commitee. Using minogrpc as the underlying network
+func TestResharing_minogrpc(t *testing.T) {
 
 	// Setting up the first dkg
 	nOld := 10
@@ -167,8 +171,8 @@ func IgnoreTestResharing_minogrpc(t *testing.T) {
 
 	// Defining the addresses
 	for i := 0; i < nOld; i++ {
-		addr := minows.("127.0.0.1", 0)
-		m, err := minows.NewMinows(addr, nil, tree.NewRouter(minows.NewAddressFactory()))
+		addr := minogrpc.ParseAddress("127.0.0.1", 0)
+		m, err := minogrpc.NewMinogrpc(addr, nil, tree.NewRouter(minogrpc.NewAddressFactory()))
 		require.NoError(t, err)
 		defer func() {
 			_ = m.GracefulStop()
@@ -181,12 +185,12 @@ func IgnoreTestResharing_minogrpc(t *testing.T) {
 	// Initializing the pedersen
 	for i, mi := range minosOld {
 		for _, mj := range minosOld {
-			err := mi.(*minows.Minows).GetCertificateStore().Store(mj.GetAddress(),
-				mj.(*minows.Minows).GetCertificateChain())
+			err := mi.(*minogrpc.Minogrpc).GetCertificateStore().Store(mj.GetAddress(),
+				mj.(*minogrpc.Minogrpc).GetCertificateChain())
 			require.NoError(t, err)
 		}
 
-		pdkg, pubkey := NewPedersen(mi.(*minows.Minows))
+		pdkg, pubkey := NewPedersen(mi.(*minogrpc.Minogrpc))
 
 		dkgsOld[i] = pdkg
 		pubkeysOld[i] = pubkey
@@ -236,8 +240,8 @@ func IgnoreTestResharing_minogrpc(t *testing.T) {
 
 	// Defining the address of the new nodes.
 	for i := 0; i < nNew; i++ {
-		addr := minows.ParseAddress("127.0.0.1", 0)
-		m, err := minows.NewMinows(addr, nil, tree.NewRouter(minows.NewAddressFactory()))
+		addr := minogrpc.ParseAddress("127.0.0.1", 0)
+		m, err := minogrpc.NewMinogrpc(addr, nil, tree.NewRouter(minogrpc.NewAddressFactory()))
 		require.NoError(t, err)
 		defer func() {
 			err := m.GracefulStop()
@@ -259,22 +263,22 @@ func IgnoreTestResharing_minogrpc(t *testing.T) {
 	// a pedersen
 	for i, mi := range minosNew[nCommon:] {
 		for _, mj := range minosNew {
-			err := mi.(*Minows).GetCertificateStore().Store(mj.GetAddress(),
-				mj.(*Minows).GetCertificateChain())
+			err := mi.(*minogrpc.Minogrpc).GetCertificateStore().Store(mj.GetAddress(),
+				mj.(*minogrpc.Minogrpc).GetCertificateChain())
 			require.NoError(t, err)
-			err = mj.(*Minows).GetCertificateStore().Store(mi.GetAddress(),
-				mi.(*Minows).GetCertificateChain())
+			err = mj.(*minogrpc.Minogrpc).GetCertificateStore().Store(mi.GetAddress(),
+				mi.(*minogrpc.Minogrpc).GetCertificateChain())
 			require.NoError(t, err)
 		}
 		for _, mk := range minosOld[nCommon:] {
-			err := mi.(*Minows).GetCertificateStore().Store(mk.GetAddress(),
-				mk.(*Minows).GetCertificateChain())
+			err := mi.(*minogrpc.Minogrpc).GetCertificateStore().Store(mk.GetAddress(),
+				mk.(*minogrpc.Minogrpc).GetCertificateChain())
 			require.NoError(t, err)
-			err = mk.(*Minows).GetCertificateStore().Store(mi.GetAddress(),
-				mi.(*Minows).GetCertificateChain())
+			err = mk.(*minogrpc.Minogrpc).GetCertificateStore().Store(mi.GetAddress(),
+				mi.(*minogrpc.Minogrpc).GetCertificateChain())
 			require.NoError(t, err)
 		}
-		pdkg, pubkey := NewPedersen(mi.(*Minows))
+		pdkg, pubkey := NewPedersen(mi.(*minogrpc.Minogrpc))
 		dkgsNew[i+nCommon] = pdkg
 		pubkeysNew[i+nCommon] = pubkey
 	}

dkg/pedersen/verifiable_test.go

@@ -119,7 +119,7 @@ func Test_VerifiableEncDec_minoch(t *testing.T) {
 	}
 }
 
-func Test_VerifiableEncDec_minows(t *testing.T) {
+func Test_VerifiableEncDec_minogrpc(t *testing.T) {
 	// we want to time the decryption for different batch sizes with different
 	// number of nodes
 
@@ -133,23 +133,39 @@ func Test_VerifiableEncDec_minows(t *testing.T) {
 	minos := make([]mino.Mino, n)
 	dkgs := make([]dkg.DKG, n)
 	addrs := make([]mino.Address, n)
-	manager := minows.NewManager()
 
-	for i := range n {
-		multi, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/80")
-		require.NoError(t, err)
+	// Create GBar. We need a generator in order to follow the encryption and
+	// decryption protocol of https://arxiv.org/pdf/2205.08529.pdf. We take an
+	// agreed data among the participants and embed it as a point. The result is
+	// the generator that we are seeking.
+	agreedData := make([]byte, 32)
+	_, err := randGen.Read(agreedData)
+	require.NoError(t, err)
+	GBar := suite.Point().Embed(agreedData, keccak.New(agreedData))
+
+	t.Log("initiating the dkg nodes ...")
+
+	for i := 0; i < n; i++ {
+		addr := minogrpc.ParseAddress("127.0.0.1", 0)
 
-		priv, _, err := crypto.GenerateKeyPair(crypto.Ed25519, 512)
+		minogrpc, err := minogrpc.NewMinogrpc(addr, nil,
+			tree.NewRouter(minogrpc.NewAddressFactory()))
 		require.NoError(t, err)
 
-		minos[i] = minows.MustCreate(manager, multi, multi, priv)
-		addrs[i] = minos[i].GetAddress()
+		defer minogrpc.GracefulStop()
+
+		minos[i] = minogrpc
+		addrs[i] = minogrpc.GetAddress()
 	}
 
 	pubkeys := make([]kyber.Point, len(minos))
 
 	for i, mino := range minos {
-		dkg, pubkey := NewPedersen(mino)
+		for _, m := range minos {
+			mino.(*minogrpc.Minogrpc).GetCertificateStore().Store(m.GetAddress(),
+				m.(*minogrpc.Minogrpc).GetCertificateChain())
+		}
+		dkg, pubkey := NewPedersen(mino.(*minogrpc.Minogrpc))
 		dkgs[i] = dkg
 		pubkeys[i] = pubkey
 	}
@@ -166,19 +182,10 @@ func Test_VerifiableEncDec_minows(t *testing.T) {
 	t.Log("setting up the dkg ...")
 
 	start := time.Now()
-	_, err := actors[0].Setup(fakeAuthority, threshold)
+	_, err = actors[0].Setup(fakeAuthority, threshold)
 	require.NoError(t, err)
 	setupTime := time.Since(start)
 
-	// Create GBar. We need a generator in order to follow the encryption and
-	// decryption protocol of https://arxiv.org/pdf/2205.08529.pdf. We take an
-	// agreed data among the participants and embed it as a point. The result is
-	// the generator that we are seeking.
-	agreedData := make([]byte, 32)
-	_, err = randGen.Read(agreedData)
-	require.NoError(t, err)
-	GBar := suite.Point().Embed(agreedData, keccak.New(agreedData))
-
 	// generating random messages in batch and encrypt them
 	for i, batchSize := range batchSizeSlice {
 		t.Logf("=== starting the process with batch size = %d === \n", batchSize)

docs/mino.md

@@ -34,7 +34,7 @@ type Players interface {
 
 It provides simple primitives to filter and get the list of addresses. Each
 implementation of Mino has its own address representation. Minoch uses Go
-channels and therefore uses string identifiers, whereas Minows uses actual
+channels and therefore uses string identifiers, whereas Minogrpc uses actual
 network addresses.
 
 This interface can later be extended to add more information to the identity of