randomness: make testable, mockable and add tests

Refactor the package so it has a settable provider. Convert the existing
init function to the real drand-based provided. Add another mock
provider that returns a fixed value instead of a proper random one.

Override the drand provided with the mock provider in tests. This way
tests can run and pass when e.g. the service is dead or when I'm on the
plane again with no internet access.

Move it to utils because this is where all the goodies that are helpful
but not really related to the trusted setup itself are going to live.

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

Author: wzmuda

cmd/init.go

@@ -8,7 +8,7 @@ import (
 	"github.com/urfave/cli/v3"
 
 	"github.com/reilabs/trusted-setup/phase2"
-	"github.com/reilabs/trusted-setup/randomness"
+	"github.com/reilabs/trusted-setup/utils/randomness"
 )
 
 func Phase2Init(_ context.Context, cmd *cli.Command) error {

randomness/randomness.go

@@ -14,6 +14,7 @@ import (
 	"github.com/reilabs/trusted-setup/phase1"
 	"github.com/reilabs/trusted-setup/phase2"
 	"github.com/reilabs/trusted-setup/r1cs"
+	"github.com/reilabs/trusted-setup/utils/randomness"
 )
 
 // testOfflineCeremony verifies the trusted setup ceremony in the offline mode.
@@ -42,7 +43,7 @@ const r1csFileName = "test.r1cs"
 const pkFileName = "test.pk"
 const vkFileName = "test.vk"
 
-var beacon = bytes.Repeat([]byte{0x42}, 32)
+var beacon []byte
 
 func setup() {
 	ccs, err := buildCcs()
@@ -53,6 +54,10 @@ func setup() {
 	if err != nil {
 		panic(err)
 	}
+
+	mockBeacon := bytes.Repeat([]byte{0x42}, 32)
+	randomness.SetProvider(&randomness.MockProvider{Beacon: mockBeacon})
+	beacon = randomness.GetBeacon()
 }
 
 func teardown() {

test/offline_ceremony_test.go

@@ -0,0 +1,59 @@
+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"
+)
+
+// drandProvider implements BeaconProvider by retrieving randomness from drand network.
+type drandProvider struct {
+	client drand.Client
+}
+
+// newDrandProvider initializes the randomness module. It connects to the drand network, so random value can be
+// obtained with GetBeacon.
+func newDrandProvider() (*drandProvider, error) {
+	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/drand_provider.go

@@ -0,0 +1,11 @@
+package randomness
+
+// MockProvider implements BeaconProvider and returns a fixed 32-byte beacon.
+type MockProvider struct {
+	Beacon []byte
+}
+
+// GetBeacon returns the 32 bytes of randomness acquired at the module initialization.
+func (m *MockProvider) GetBeacon() []byte {
+	return m.Beacon
+}

utils/randomness/mock_provider.go

@@ -0,0 +1,36 @@
+// Package randomness provides "publicly verifiable, unbiased and unpredictable random values" as guaranteed
+// by the drand organization (https://github.com/drand/drand).
+package randomness
+
+// 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/"
+
+// BeaconProvider defines an interface to get 32 bytes of randomness (beacon).
+type BeaconProvider interface {
+	GetBeacon() []byte
+}
+
+// provider is a handler for randomness provider.
+var provider BeaconProvider
+
+// init is called at package initialization and sets the default provider.
+func init() {
+	p, err := newDrandProvider()
+	if err != nil {
+		panic(err)
+	}
+	provider = p
+}
+
+// SetProvider sets the BeaconProvider used by the package. This allows overriding randomness source (e.g. for tests).
+func SetProvider(p BeaconProvider) {
+	provider = p
+}
+
+// GetBeacon returns the 32 bytes of randomness acquired at the module initialization or from the currently set provider.
+func GetBeacon() []byte {
+	return provider.GetBeacon()
+}

utils/randomness/randomness.go

@@ -0,0 +1,30 @@
+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) // 32 bytes of value 0x42
+	mock := &randomness.MockProvider{Beacon: mockValue}
+
+	// Override the default provider with the mock.
+	randomness.SetProvider(mock)
+
+	got := randomness.GetBeacon()
+	if !bytes.Equal(got, mockValue) {
+		t.Fatalf("GetBeacon() = %x; want %x", got, mockValue)
+	}
+}
+
+func TestGetBeaconWithDrand(t *testing.T) {
+	got := randomness.GetBeacon()
+
+	assert.NotEmpty(t, got)
+	assert.Equal(t, 32, len(got))
+}