utils: randomness: remove mock provider

The current architecture assumes that whoever needs randomness,
will just accept it as an argument. It's the caller's responsibility to
make sure the random value is cached for subsequent uses.

In tests its enough to just define any byte array and reuse it.

Signed-off-by: Wojciech Zmuda <[email protected]>

Author: wzmuda

offline/actions/init.go

@@ -12,7 +12,7 @@ import (
 )
 
 func Phase2Init(_ context.Context, cmd *cli.Command) error {
-	rand, err := randomness.NewDrandProvider()
+	rand, err := randomness.New()
 	if err != nil {
 		return err
 	}

offline/test/offline_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/reilabs/trusted-setup/offline/phase2"
 	"github.com/reilabs/trusted-setup/offline/r1cs"
 	test_circuit "github.com/reilabs/trusted-setup/test"
-	"github.com/reilabs/trusted-setup/utils/randomness"
 )
 
 // testOfflineCeremony verifies the trusted setup ceremony in the offline mode.
@@ -44,7 +43,7 @@ var (
 	srsCommonsFileName string
 	pkFileName         string
 	vkFileName         string
-	rand               randomness.MockProvider
+	rand               []byte
 )
 
 func createTempFile(pattern string) *os.File {
@@ -80,8 +79,7 @@ func setup() {
 	fVk := createTempFile("vk")
 	vkFileName = fVk.Name()
 
-	mockBeacon := bytes.Repeat([]byte{0x42}, 32)
-	rand = randomness.MockProvider{Beacon: mockBeacon}
+	rand = bytes.Repeat([]byte{0x42}, 32)
 }
 
 func teardown() {
@@ -130,7 +128,7 @@ func testPtau(t *testing.T) {
 }
 
 func testInit(t *testing.T) {
-	assert.NoError(t, phase2.Init(phase1FileName, r1csFileName, phase2FileName, srsCommonsFileName, rand.GetBeacon()))
+	assert.NoError(t, phase2.Init(phase1FileName, r1csFileName, phase2FileName, srsCommonsFileName, rand))
 
 	p2, err := phase2.FromFile(phase2FileName)
 	assert.NoError(t, err)
@@ -187,7 +185,7 @@ func testExtractKeys(t *testing.T) {
 	assert.NoError(
 		t,
 		phase2.ExtractKeys(
-			r1csFileName, srsCommonsFileName, phase2Contributions[1:], pkFileName, vkFileName, rand.GetBeacon(),
+			r1csFileName, srsCommonsFileName, phase2Contributions[1:], pkFileName, vkFileName, rand,
 		),
 	)
 }

utils/randomness/drand_provider.go

@@ -2,7 +2,70 @@
 // by the drand organization (https://github.com/drand/drand).
 package randomness
 
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/drand/go-clients/client"
+	"github.com/drand/go-clients/client/http"
+	"github.com/drand/go-clients/drand"
+)
+
 // BeaconProvider defines an interface to get 32 bytes of randomness (beacon).
 type BeaconProvider interface {
 	GetBeacon() []byte
 }
+
+// drandProvider implements BeaconProvider by retrieving randomness from drand network.
+type drandProvider struct {
+	client drand.Client
+}
+
+// New initializes the randomness module. It connects to the drand network, so random value can be
+// obtained with GetBeacon.
+func New() (BeaconProvider, error) {
+	// Default network chain hash as per the drand project documentation.
+	const chainHash = "8990e7a9aaed2ffed73dbd7092123d6f289930540d7651336225dc172e51b2ce"
+	// API returning the randomness, as per the drand project documentation.
+	const apiHost = "https://api.drand.sh/"
+
+	httpClient, err := http.NewSimpleClient(apiHost, chainHash)
+	if err != nil {
+		panic(err)
+	}
+	chb, err := hex.DecodeString(chainHash)
+	if err != nil {
+		panic(err)
+	}
+
+	p := drandProvider{}
+	p.client, err = client.New(
+		client.From(httpClient),
+		client.WithChainHash(chb),
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	return &p, nil
+}
+
+// GetBeacon returns the 32 bytes of randomness.
+func (d *drandProvider) GetBeacon() []byte {
+	const mostRecentKnownRound = 0
+	r, err := d.client.Get(context.Background(), mostRecentKnownRound)
+	if err != nil {
+		panic(err)
+	}
+
+	beacon := r.GetRandomness()
+	if len(beacon) != 32 {
+		panic(fmt.Errorf("randomness: expected 32 bytes, got %d", len(beacon)))
+	}
+	if beacon == nil {
+		panic(fmt.Errorf("randomness: drand did not return randomness"))
+	}
+
+	return beacon
+}

utils/randomness/mock_provider.go

@@ -1,29 +1,18 @@
 package randomness_test
 
 import (
-	"bytes"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 
 	"github.com/reilabs/trusted-setup/utils/randomness"
 )
 
-func TestGetBeaconWithMock(t *testing.T) {
-	mockValue := bytes.Repeat([]byte{0x42}, 32)
-	mock := &randomness.MockProvider{Beacon: mockValue}
-
-	got := mock.GetBeacon()
-	if !bytes.Equal(got, mockValue) {
-		t.Fatalf("GetBeacon() = %x; want %x", got, mockValue)
-	}
-}
-
-func TestGetBeaconWithDrand(t *testing.T) {
-	drand, err := randomness.NewDrandProvider()
+func Test(t *testing.T) {
+	r, err := randomness.New()
 	assert.NoError(t, err)
 
-	got := drand.GetBeacon()
+	got := r.GetBeacon()
 	assert.NotEmpty(t, got)
 	assert.Equal(t, 32, len(got))
 }