v0.26.3 merge master

Makefile

@@ -3,7 +3,7 @@ SHORT_COMMIT := $(shell git rev-parse --short HEAD)
 # The Git commit hash
 COMMIT := $(shell git rev-parse HEAD)
 # The tag of the current commit, otherwise empty
-VERSION := $(shell git describe --tags --abbrev=2 --match "v*" 2>/dev/null)
+VERSION := $(shell git describe --tags --abbrev=2 --match "v*" --match "secure-cadence*" 2>/dev/null)
 
 # Image tag: if image tag is not set, set it with version (or short commit if empty)
 ifeq (${IMAGE_TAG},)

crypto/random/rand_test.go

@@ -2,10 +2,10 @@ package random
 
 import (
 	"bytes"
-	crand "crypto/rand"
 	"fmt"
-	mrand "math/rand"
+	"math/rand"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -82,26 +82,33 @@ func TestChacha20Compliance(t *testing.T) {
 	})
 }
 
+func seedMathRand(t *testing.T) {
+	r := time.Now().UnixNano()
+	rand.Seed(r)
+	t.Logf("math rand seed is %d", r)
+}
+
 // The tests are targeting the PRG implementations in the package.
 // For now, the tests are only used for Chacha20 PRG, but can be ported
 // to test another PRG implementation.
 
 // Simple unit testing of Uint using a very basic randomness test.
 // It doesn't evaluate randomness of the output and doesn't perform advanced statistical tests.
 func TestUint(t *testing.T) {
+	seedMathRand(t)
 
 	seed := make([]byte, Chacha20SeedLen)
-	crand.Read(seed)
+	rand.Read(seed)
 	customizer := make([]byte, Chacha20CustomizerMaxLen)
-	crand.Read(customizer)
+	rand.Read(customizer)
 
 	rng, err := NewChacha20PRG(seed, customizer)
 	require.NoError(t, err)
 
 	t.Run("basic randomness", func(t *testing.T) {
 		sampleSize := 80000
 		tolerance := 0.05
-		sampleSpace := uint64(10 + mrand.Intn(100))
+		sampleSpace := uint64(10 + rand.Intn(100))
 		distribution := make([]float64, sampleSpace)
 
 		for i := 0; i < sampleSize; i++ {
@@ -126,11 +133,12 @@ func TestUint(t *testing.T) {
 //
 // SubPermutation tests cover Permutation as well.
 func TestSubPermutation(t *testing.T) {
+	seedMathRand(t)
 
 	seed := make([]byte, Chacha20SeedLen)
-	crand.Read(seed)
+	rand.Read(seed)
 	customizer := make([]byte, Chacha20CustomizerMaxLen)
-	crand.Read(customizer)
+	rand.Read(customizer)
 
 	rng, err := NewChacha20PRG(seed, customizer)
 	require.NoError(t, err)
@@ -141,13 +149,13 @@ func TestSubPermutation(t *testing.T) {
 		subsetSize := 20
 
 		// statictics parameters
-		sampleSize := 80000
+		sampleSize := 85000
 		tolerance := 0.05
 		// tests the subset sampling randomness
 		samplingDistribution := make([]float64, listSize)
 		// tests the subset ordering randomness (using a particular element testElement)
 		orderingDistribution := make([]float64, subsetSize)
-		testElement := mrand.Intn(listSize)
+		testElement := rand.Intn(listSize)
 
 		for i := 0; i < sampleSize; i++ {
 			shuffledlist, err := rng.SubPermutation(listSize, subsetSize)
@@ -208,11 +216,12 @@ func TestSubPermutation(t *testing.T) {
 // Simple unit testing of Shuffle using a very basic randomness test.
 // It doesn't evaluate randomness of the output and doesn't perform advanced statistical tests.
 func TestShuffle(t *testing.T) {
+	seedMathRand(t)
 
 	seed := make([]byte, Chacha20SeedLen)
-	crand.Read(seed)
+	rand.Read(seed)
 	customizer := make([]byte, Chacha20CustomizerMaxLen)
-	crand.Read(customizer)
+	rand.Read(customizer)
 
 	rng, err := NewChacha20PRG(seed, customizer)
 	require.NoError(t, err)
@@ -224,7 +233,7 @@ func TestShuffle(t *testing.T) {
 		tolerance := 0.05
 		// the distribution of a particular element of the list, testElement
 		distribution := make([]float64, listSize)
-		testElement := mrand.Intn(listSize)
+		testElement := rand.Intn(listSize)
 		// Slice to shuffle
 		list := make([]int, 0, listSize)
 		for i := 0; i < listSize; i++ {
@@ -290,11 +299,12 @@ func TestShuffle(t *testing.T) {
 }
 
 func TestSamples(t *testing.T) {
+	seedMathRand(t)
 
 	seed := make([]byte, Chacha20SeedLen)
-	crand.Read(seed)
+	rand.Read(seed)
 	customizer := make([]byte, Chacha20CustomizerMaxLen)
-	crand.Read(customizer)
+	rand.Read(customizer)
 
 	rng, err := NewChacha20PRG(seed, customizer)
 	require.NoError(t, err)
@@ -311,7 +321,7 @@ func TestSamples(t *testing.T) {
 		samplingDistribution := make([]float64, listSize)
 		// tests the subset ordering randomness (using a particular element testElement)
 		orderingDistribution := make([]float64, samplesSize)
-		testElement := mrand.Intn(listSize)
+		testElement := rand.Intn(listSize)
 		// Slice to shuffle
 		list := make([]int, 0, listSize)
 		for i := 0; i < listSize; i++ {
@@ -380,19 +390,21 @@ func TestSamples(t *testing.T) {
 // TestStateRestore tests the serilaization and deserialization functions
 // Store and Restore
 func TestStateRestore(t *testing.T) {
+	seedMathRand(t)
+
 	// generate a seed
 	seed := make([]byte, Chacha20SeedLen)
-	crand.Read(seed)
+	rand.Read(seed)
 	customizer := make([]byte, Chacha20CustomizerMaxLen)
-	crand.Read(customizer)
+	rand.Read(customizer)
 	t.Logf("seed is %x, customizer is %x\n", seed, customizer)
 
 	// create an rng
 	rng, err := NewChacha20PRG(seed, customizer)
 	require.NoError(t, err)
 
 	// evolve the internal state of the rng
-	iterations := mrand.Intn(1000)
+	iterations := rand.Intn(1000)
 	for i := 0; i < iterations; i++ {
 		_ = rng.UintN(1024)
 	}
@@ -409,7 +421,7 @@ func TestStateRestore(t *testing.T) {
 	assert.True(t, bytes.Equal(state, secondRng.Store()), "Store o Restore is not identity")
 
 	// check the 2 PRGs are generating identical outputs
-	iterations = mrand.Intn(1000)
+	iterations = rand.Intn(1000)
 	for i := 0; i < iterations; i++ {
 		rand1 := rng.UintN(1024)
 		rand2 := secondRng.UintN(1024)

engine/access/access_test.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"os"
 	"testing"
-	"time"
 
 	"github.com/dgraph-io/badger/v2"
 	accessproto "github.com/onflow/flow/protobuf/go/flow/access"
@@ -30,6 +29,7 @@ import (
 	"github.com/onflow/flow-go/model/flow"
 	"github.com/onflow/flow-go/model/flow/factory"
 	"github.com/onflow/flow-go/model/flow/filter"
+	"github.com/onflow/flow-go/module/irrecoverable"
 	"github.com/onflow/flow-go/module/mempool/stdmap"
 	"github.com/onflow/flow-go/module/metrics"
 	module "github.com/onflow/flow-go/module/mock"
@@ -621,6 +621,13 @@ func (suite *Suite) TestGetSealedTransaction() {
 			transactions, results, receipts, metrics, collectionsToMarkFinalized, collectionsToMarkExecuted, blocksToMarkExecuted, rpcEng)
 		require.NoError(suite.T(), err)
 
+		background, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		ctx, _ := irrecoverable.WithSignaler(background)
+		ingestEng.Start(ctx)
+		<-ingestEng.Ready()
+
 		// 1. Assume that follower engine updated the block storage and the protocol state. The block is reported as sealed
 		err = blocks.Store(&block)
 		require.NoError(suite.T(), err)
@@ -643,7 +650,6 @@ func (suite *Suite) TestGetSealedTransaction() {
 			err = ingestEng.Process(engine.ReceiveReceipts, enNodeIDs[0], r)
 			require.NoError(suite.T(), err)
 		}
-		unittest.AssertClosesBefore(suite.T(), ingestEng.Done(), 3*time.Second)
 
 		// 5. Client requests a transaction
 		tx := collection.Transactions[0]
@@ -747,9 +753,6 @@ func (suite *Suite) TestExecuteScript() {
 			require.NoError(suite.T(), err)
 		}
 
-		// wait for the receipt to be persisted
-		unittest.AssertClosesBefore(suite.T(), ingestEng.Done(), 3*time.Second)
-
 		ctx := context.Background()
 
 		script := []byte("dummy script")
@@ -781,6 +784,9 @@ func (suite *Suite) TestExecuteScript() {
 
 		suite.Run("execute script at latest block", func() {
 			suite.state.On("Sealed").Return(suite.snapshot, nil).Maybe()
+			suite.state.
+				On("AtBlockID", lastBlock.ID()).
+				Return(suite.snapshot, nil)
 
 			expectedResp := setupExecClientMock(lastBlock.ID())
 			req := accessproto.ExecuteScriptAtLatestBlockRequest{
@@ -791,6 +797,10 @@ func (suite *Suite) TestExecuteScript() {
 		})
 
 		suite.Run("execute script at block id", func() {
+			suite.state.
+				On("AtBlockID", prevBlock.ID()).
+				Return(suite.snapshot, nil)
+
 			expectedResp := setupExecClientMock(prevBlock.ID())
 			id := prevBlock.ID()
 			req := accessproto.ExecuteScriptAtBlockIDRequest{
@@ -802,6 +812,10 @@ func (suite *Suite) TestExecuteScript() {
 		})
 
 		suite.Run("execute script at block height", func() {
+			suite.state.
+				On("AtBlockID", prevBlock.ID()).
+				Return(suite.snapshot, nil)
+
 			expectedResp := setupExecClientMock(prevBlock.ID())
 			req := accessproto.ExecuteScriptAtBlockHeightRequest{
 				BlockHeight: prevBlock.Header.Height,