diff --git a/config/initiator.yaml b/config/initiator.yaml index eb3cc927..7d32cc1e 100644 --- a/config/initiator.yaml +++ b/config/initiator.yaml @@ -1,6 +1,6 @@ -threshold: 4 +threshold: 3 operatorIDs: [1, 2, 3, 4] -withdrawAddress: "0100000000000000000000001d2f14d2dffee594b4093d42e4bc1b0ea55e8aa7" +withdrawAddress: "0x0000000000000000000000000000000000000009" owner: "0x81592c3de184a3e2c0dcb5a261bc107bfa91f494" nonce: 4 fork: "00000000" diff --git a/pkgs/client/client_test.go b/pkgs/client/client_test.go index 48b44367..c5073008 100644 --- a/pkgs/client/client_test.go +++ b/pkgs/client/client_test.go @@ -46,109 +46,61 @@ const operatorsMetaData = `[ const exmaplePath = "../../examples/" - -func TestHappyFlow(t *testing.T) { +func TestClientAtOperatorMisbehave(t *testing.T) { + logger := logrus.NewEntry(logrus.New()) + eg := errgroup.Group{} + srv2 := CreateTestServer(t, 2) + srv3 := CreateTestServer(t, 3) + srv4 := CreateTestServer(t, 4) + eg.Go(func() error { + return srv2.Start(3031) + }) + eg.Go(func() error { + return srv3.Start(3032) + }) + eg.Go(func() error { + return srv4.Start(3033) + }) + logger.Infof("Servers created") t.Run("test wrong server key", func(t *testing.T) { - logger := logrus.NewEntry(logrus.New()) - logger.Infof("Starting intg test") srv1 := CreateTestServerRandomKey(t, 1) - srv2 := CreateTestServer(t, 2) - srv3 := CreateTestServer(t, 3) - srv4 := CreateTestServer(t, 4) - logger.Infof("Servers created") - eg := errgroup.Group{} eg.Go(func() error { return srv1.Start(3030) }) - eg.Go(func() error { - return srv2.Start(3031) - }) - eg.Go(func() error { - return srv3.Start(3032) - }) - eg.Go(func() error { - return srv4.Start(3033) - }) - logger.Infof("Servers Started") opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData)) require.NoError(t, err) clnt := client.New(opmap) - logger.Infof("Client created") - logger.Infof("Client Starting dkg") _, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 3, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0) require.ErrorContains(t, err, "my operator is missing inside the op list") srv1.Stop() - srv2.Stop() - srv3.Stop() - srv4.Stop() - - require.ErrorIs(t, http.ErrServerClosed, eg.Wait()) }) t.Run("test wrong partial deposit signature", func(t *testing.T) { - logger := logrus.NewEntry(logrus.New()) - logger.Infof("Starting intg test") eveMsg := dkg.EveTest{ WrongPartialSig: "0x87912f24669427628885cf0b70385b94694951626805ff565f4d2a0b74c433a45b279769ff23c23c8dd4ae3625fa06c20df368c0dc24931f3ebe133b3e1fed7d3477c51fa291e61052b0286c7fc453bb5e10346c43eadda9ef1bac8db14acda4", } - srv1 := CreateEveTestServer(t, 1, &eveMsg) - srv2 := CreateTestServer(t, 2) - srv3 := CreateTestServer(t, 3) - srv4 := CreateTestServer(t, 4) - logger.Infof("Servers created") - eg := errgroup.Group{} eg.Go(func() error { return srv1.Start(3030) }) - eg.Go(func() error { - return srv2.Start(3031) - }) - eg.Go(func() error { - return srv3.Start(3032) - }) - eg.Go(func() error { - return srv4.Start(3033) - }) - logger.Infof("Servers Started") + opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData)) require.NoError(t, err) clnt := client.New(opmap) - logger.Infof("Client created") - logger.Infof("Client Starting dkg") _, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 3, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0) require.ErrorContains(t, err, "error verifying partial deposit signature") srv1.Stop() - srv2.Stop() - srv3.Stop() - srv4.Stop() - require.ErrorIs(t, http.ErrServerClosed, eg.Wait()) }) t.Run("test wrong request ID", func(t *testing.T) { - logger := logrus.NewEntry(logrus.New()) - logger.Infof("Starting intg test") eveMsg := dkg.EveTest{ WrongID: "0x0000000000000000630ab8af69364a6db7b6d7d59bb60f23", } srv1 := CreateEveTestServer(t, 1, &eveMsg) - srv2 := CreateTestServer(t, 2) - srv3 := CreateTestServer(t, 3) - srv4 := CreateTestServer(t, 4) - logger.Infof("Servers created") eg := errgroup.Group{} eg.Go(func() error { return srv1.Start(3030) }) - eg.Go(func() error { - return srv2.Start(3031) - }) - eg.Go(func() error { - return srv3.Start(3032) - }) - eg.Go(func() error { - return srv4.Start(3033) - }) logger.Infof("Servers Started") opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData)) require.NoError(t, err) @@ -158,48 +110,6 @@ func TestHappyFlow(t *testing.T) { _, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 3, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0) require.ErrorContains(t, err, "DKG result has wrong ID") srv1.Stop() - srv2.Stop() - srv3.Stop() - srv4.Stop() - require.ErrorIs(t, http.ErrServerClosed, eg.Wait()) - }) - t.Run("test operator timeout", func(t *testing.T) { - logger := logrus.NewEntry(logrus.New()) - logger.Infof("Starting intg test") - eveMsg := dkg.EveTest{ - Timeout: time.Second * 30, - } - srv1 := CreateEveTestServer(t, 1, &eveMsg) - srv2 := CreateTestServer(t, 2) - srv3 := CreateTestServer(t, 3) - srv4 := CreateTestServer(t, 4) - logger.Infof("Servers created") - eg := errgroup.Group{} - eg.Go(func() error { - return srv1.Start(3030) - }) - eg.Go(func() error { - return srv2.Start(3031) - }) - eg.Go(func() error { - return srv3.Start(3032) - }) - eg.Go(func() error { - return srv4.Start(3033) - }) - logger.Infof("Servers Started") - opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData)) - require.NoError(t, err) - clnt := client.New(opmap) - logger.Infof("Client created") - logger.Infof("Client Starting dkg") - _, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 3, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0) - require.ErrorContains(t, err, "Client.Timeout exceeded while awaiting headers") - srv1.Stop() - srv2.Stop() - srv3.Stop() - srv4.Stop() - require.ErrorIs(t, http.ErrServerClosed, eg.Wait()) }) t.Run("test wrong threshold", func(t *testing.T) { opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData)) @@ -208,6 +118,48 @@ func TestHappyFlow(t *testing.T) { _, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 10, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0) require.ErrorContains(t, err, "wrong threshold") }) + srv2.Stop() + srv3.Stop() + srv4.Stop() + require.ErrorIs(t, http.ErrServerClosed, eg.Wait()) +} + +func TestTimeout(t *testing.T) { + eveMsg := dkg.EveTest{ + Timeout: time.Second * 30, + } + + logger := logrus.NewEntry(logrus.New()) + eg := errgroup.Group{} + srv1 := CreateEveTestServer(t, 1, &eveMsg) + srv2 := CreateTestServer(t, 2) + srv3 := CreateTestServer(t, 3) + srv4 := CreateTestServer(t, 4) + + eg.Go(func() error { + return srv1.Start(3030) + }) + eg.Go(func() error { + return srv2.Start(3031) + }) + eg.Go(func() error { + return srv3.Start(3032) + }) + eg.Go(func() error { + return srv4.Start(3033) + }) + logger.Infof("Servers created") + + opmap, err := load.LoadOperatorsJson([]byte(operatorsMetaData)) + require.NoError(t, err) + clnt := client.New(opmap) + _, _, err = clnt.StartDKG(common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), []uint64{1, 2, 3, 4}, 3, [4]byte{0, 0, 0, 0}, "mainnnet", common.HexToAddress("0x0000000000000000000000000000000000000007"), 0) + require.ErrorContains(t, err, "Client.Timeout exceeded while awaiting headers") + srv1.Stop() + srv2.Stop() + srv3.Stop() + srv4.Stop() + require.ErrorIs(t, http.ErrServerClosed, eg.Wait()) } func CreateTestServer(t *testing.T, id uint64) *test_server.Server { pk, err := load.EncryptedPrivateKey(exmaplePath+"server"+fmt.Sprintf("%v", id)+"/encrypted_private_key.json", "12345678") @@ -233,17 +185,10 @@ func CreateEveTestServer(t *testing.T, id uint64, eveCase *dkg.EveTest) *test_se func newEthAddress(t *testing.T) common.Address { privateKey, err := eth_crypto.GenerateKey() require.NoError(t, err) - - //privateKeyBytes := crypto.FromECDSA(privateKey) - publicKey := privateKey.Public() publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey) require.True(t, ok) - - //publicKeyBytes := crypto.FromECDSAPub(publicKeyECDSA) - address := eth_crypto.PubkeyToAddress(*publicKeyECDSA) - return address } diff --git a/pkgs/dkg/drand.go b/pkgs/dkg/drand.go index 784d8d31..bed065dc 100644 --- a/pkgs/dkg/drand.go +++ b/pkgs/dkg/drand.go @@ -152,7 +152,7 @@ func (o *LocalOwner) StartDKG() error { Public: p, }) } - o.Logger.Infof("Staring DKG with nodes", nodes) + o.Logger.Infof("Staring DKG with nodes %v", nodes) // New protocol p, err := wire.NewDKGProtocol(&wire.Config{ diff --git a/pkgs/server/server_test.go b/pkgs/server/server_test.go index 5c407e35..a8be3214 100644 --- a/pkgs/server/server_test.go +++ b/pkgs/server/server_test.go @@ -19,7 +19,7 @@ import ( const exmaplePath = "../../examples/" -func TestGeneralRateLimit(t *testing.T) { +func TestRateLimit(t *testing.T) { pk, err := load.EncryptedPrivateKey(exmaplePath+"server"+fmt.Sprintf("%v", 1)+"/encrypted_private_key.json", "12345678") require.NoError(t, err) srv := New(pk) @@ -27,117 +27,104 @@ func TestGeneralRateLimit(t *testing.T) { eg.Go(func() error { return srv.Start(3030) }) - - client := req.C() - r := client.R() - - r.SetBodyBytes([]byte{}) - - // Send requests - errChan := make(chan []byte) - time.Sleep(time.Second) - var wg sync.WaitGroup - wg.Add(1) - go func() { - defer close(errChan) - defer wg.Done() - for i := 0; i < 1000; i++ { - res, err := r.Post(fmt.Sprintf("%v/%v", "http://localhost:3030", "dkg")) - require.NoError(t, err) - if res.Status == "429 Too Many Requests" { - b, err := io.ReadAll(res.Body) + t.Run("test init route rate limit", func(t *testing.T) { + ops := make(map[uint64]client.Operator) + ops[1] = client.Operator{"http://localhost:3030", 1, &srv.State.privateKey.PublicKey} + + parts := make([]*wire.Operator, 0, 0) + for _, id := range []uint64{1} { + op, ok := ops[id] + if !ok { + t.Fatalf("no op") + } + pkBytes, err := crypto.EncodePublicKey(op.PubKey) + if err != nil { require.NoError(t, err) - errChan <- b } + parts = append(parts, &wire.Operator{ + ID: op.ID, + PubKey: pkBytes, + }) } - }() - for errResp := range errChan { - require.NotEmpty(t, errResp) - require.Equal(t, "{\"error\": \"Too many requests to operator\"}", string(errResp)) - close(errChan) - wg.Done() - } - wg.Wait() -} -func TestInitRateLimit(t *testing.T) { - pk, err := load.EncryptedPrivateKey(exmaplePath+"server"+fmt.Sprintf("%v", 1)+"/encrypted_private_key.json", "12345678") - require.NoError(t, err) - srv := New(pk) - eg := errgroup.Group{} - eg.Go(func() error { - err := srv.Start(3030) + init := &wire.Init{ + Operators: parts, + T: 3, + WithdrawalCredentials: common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), + Fork: [4]byte{0, 0, 0, 0}, + Owner: common.HexToAddress("0x0000000000000000000000000000000000000007"), + Nonce: 0, + } + sszinit, err := init.MarshalSSZ() require.NoError(t, err) - return err - }) - - ops := make(map[uint64]client.Operator) - ops[1] = client.Operator{"http://localhost:3030", 1, &srv.State.privateKey.PublicKey} - parts := make([]*wire.Operator, 0, 0) - for _, id := range []uint64{1} { - op, ok := ops[id] - if !ok { - t.Fatalf("no op") + ts := &wire.Transport{ + Type: wire.InitMessageType, + Identifier: [24]byte{}, + Data: sszinit, } - pkBytes, err := crypto.EncodePublicKey(op.PubKey) - if err != nil { - require.NoError(t, err) - } - parts = append(parts, &wire.Operator{ - ID: op.ID, - PubKey: pkBytes, - }) - } - - init := &wire.Init{ - Operators: parts, - T: 3, - WithdrawalCredentials: common.HexToAddress("0x0000000000000000000000000000000000000009").Bytes(), - Fork: [4]byte{0, 0, 0, 0}, - Owner: common.HexToAddress("0x0000000000000000000000000000000000000007"), - Nonce: 0, - } - sszinit, err := init.MarshalSSZ() - require.NoError(t, err) - - ts := &wire.Transport{ - Type: wire.InitMessageType, - Identifier: [24]byte{}, - Data: sszinit, - } - - tsssz, err := ts.MarshalSSZ() - require.NoError(t, err) - - client := req.C() - r := client.R() - r.SetBodyBytes(tsssz) + tsssz, err := ts.MarshalSSZ() + require.NoError(t, err) - // Send requests - errChan := make(chan []byte) - time.Sleep(time.Second) - var wg sync.WaitGroup - wg.Add(1) - go func() { - defer close(errChan) - defer wg.Done() - for i := 0; i < 100; i++ { - res, err := r.Post(fmt.Sprintf("%v/%v", "http://localhost:3030", "init")) - require.NoError(t, err) - if res.Status == "429 Too Many Requests" { - b, err := io.ReadAll(res.Body) + client := req.C() + r := client.R() + + r.SetBodyBytes(tsssz) + + // Send requests + errChan := make(chan []byte) + time.Sleep(time.Second) + var wg sync.WaitGroup + wg.Add(1) + go func() { + defer close(errChan) + defer wg.Done() + for i := 0; i < 100; i++ { + res, err := r.Post(fmt.Sprintf("%v/%v", "http://localhost:3030", "init")) + require.NoError(t, err) + if res.Status == "429 Too Many Requests" { + b, err := io.ReadAll(res.Body) + require.NoError(t, err) + errChan <- b + } + } + }() + for errResp := range errChan { + require.NotEmpty(t, errResp) + require.Equal(t, "{\"error\": \"Too many requests to initiate DKG\"}", string(errResp)) + } + wg.Wait() + }) + t.Run("test general rate limit", func(t *testing.T) { + client := req.C() + r := client.R() + + r.SetBodyBytes([]byte{}) + + // Send requests + errChan := make(chan []byte) + time.Sleep(time.Second) + var wg sync.WaitGroup + wg.Add(1) + go func() { + defer close(errChan) + defer wg.Done() + for i := 0; i < 1000; i++ { + res, err := r.Post(fmt.Sprintf("%v/%v", "http://localhost:3030", "dkg")) require.NoError(t, err) - errChan <- b + if res.Status == "429 Too Many Requests" { + b, err := io.ReadAll(res.Body) + require.NoError(t, err) + errChan <- b + } } + }() + for errResp := range errChan { + require.NotEmpty(t, errResp) + require.Equal(t, "{\"error\": \"Too many requests to operator\"}", string(errResp)) } - }() - for errResp := range errChan { - require.NotEmpty(t, errResp) - require.Equal(t, "{\"error\": \"Too many requests to initiate DKG\"}", string(errResp)) - close(errChan) - wg.Done() - } - wg.Wait() + wg.Wait() + }) + srv.HttpServer.Close() }