Merge branch 'master' into optimize-circleci-upload-stage

Author: algojack

.circleci/config.yml

@@ -48,7 +48,7 @@ executors:
 
 workflows:
   version: 2
-  build_pr:
+  "circleci_build_and_test":
     jobs:
       - codegen_verification
 

data/transactions/logic/assembler.go

@@ -472,13 +472,16 @@ func asmPushInt(ops *OpStream, spec *OpSpec, args []string) error {
 	return nil
 }
 func asmPushBytes(ops *OpStream, spec *OpSpec, args []string) error {
-	if len(args) != 1 {
-		return ops.errorf("%s needs one argument", spec.Name)
+	if len(args) == 0 {
+		return ops.errorf("%s operation needs byte literal argument", spec.Name)
 	}
-	val, _, err := parseBinaryArgs(args)
+	val, consumed, err := parseBinaryArgs(args)
 	if err != nil {
 		return ops.error(err)
 	}
+	if len(args) != consumed {
+		return ops.errorf("%s operation with extraneous argument", spec.Name)
+	}
 	ops.pending.WriteByte(spec.Opcode)
 	var scratch [binary.MaxVarintLen64]byte
 	vlen := binary.PutUvarint(scratch[:], uint64(len(val)))
@@ -636,12 +639,15 @@ func parseStringLiteral(input string) (result []byte, err error) {
 // byte "this is a string\n"
 func assembleByte(ops *OpStream, spec *OpSpec, args []string) error {
 	if len(args) == 0 {
-		return ops.error("byte operation needs byte literal argument")
+		return ops.errorf("%s operation needs byte literal argument", spec.Name)
 	}
-	val, _, err := parseBinaryArgs(args)
+	val, consumed, err := parseBinaryArgs(args)
 	if err != nil {
 		return ops.error(err)
 	}
+	if len(args) != consumed {
+		return ops.errorf("%s operation with extraneous argument", spec.Name)
+	}
 	ops.ByteLiteral(val)
 	return nil
 }

data/transactions/logic/assembler_test.go

@@ -475,6 +475,9 @@ func testProg(t testing.TB, source string, ver uint64, expected ...expect) *OpSt
 		require.NoError(t, err)
 		require.Equal(t, ops.Program, ops2.Program)
 	} else {
+		if err == nil {
+			t.Log(program)
+		}
 		require.Error(t, err)
 		errors := ops.Errors
 		for _, exp := range expected {
@@ -507,6 +510,7 @@ func testProg(t testing.TB, source string, ver uint64, expected ...expect) *OpSt
 }
 
 func testLine(t *testing.T, line string, ver uint64, expected string) {
+	t.Helper()
 	// By embedding the source line between two other lines, the
 	// test for the correct line number in the error is more
 	// meaningful.
@@ -517,6 +521,7 @@ func testLine(t *testing.T, line string, ver uint64, expected string) {
 	}
 	testProg(t, source, ver, expect{2, expected})
 }
+
 func TestAssembleTxna(t *testing.T) {
 	partitiontest.PartitionTest(t)
 
@@ -661,6 +666,7 @@ func TestAssembleBytes(t *testing.T) {
 	variations := []string{
 		"byte b32 MFRGGZDFMY",
 		"byte base32 MFRGGZDFMY",
+		"byte base32  MFRGGZDFMY",
 		"byte base32(MFRGGZDFMY)",
 		"byte b32(MFRGGZDFMY)",
 		"byte b32 MFRGGZDFMY======",
@@ -679,6 +685,11 @@ func TestAssembleBytes(t *testing.T) {
 	expectedDefaultConsts := "0126010661626364656628"
 	expectedOptimizedConsts := "018006616263646566"
 
+	bad := [][]string{
+		{"byte", "...operation needs byte literal argument"},
+		{`byte "john" "doe"`, "...operation with extraneous argument"},
+	}
+
 	for v := uint64(1); v <= AssemblerMaxVersion; v++ {
 		t.Run(fmt.Sprintf("v=%d", v), func(t *testing.T) {
 			expected := expectedDefaultConsts
@@ -690,8 +701,19 @@ func TestAssembleBytes(t *testing.T) {
 				ops := testProg(t, vi, v)
 				s := hex.EncodeToString(ops.Program)
 				require.Equal(t, mutateProgVersion(v, expected), s)
+				// pushbytes should take the same input
+				if v >= 3 {
+					testProg(t, strings.Replace(vi, "byte", "pushbytes", 1), v)
+				}
 			}
 
+			for _, b := range bad {
+				testProg(t, b[0], v, expect{1, b[1]})
+				// pushbytes should produce the same errors
+				if v >= 3 {
+					testProg(t, strings.Replace(b[0], "byte", "pushbytes", 1), v, expect{1, b[1]})
+				}
+			}
 		})
 	}
 }
@@ -1448,7 +1470,7 @@ func TestConstantArgs(t *testing.T) {
 	}
 	for v := uint64(3); v <= AssemblerMaxVersion; v++ {
 		testProg(t, "pushint", v, expect{1, "pushint needs one argument"})
-		testProg(t, "pushbytes", v, expect{1, "pushbytes needs one argument"})
+		testProg(t, "pushbytes", v, expect{1, "pushbytes operation needs byte literal argument"})
 	}
 
 }

data/transactions/teal.go

@@ -37,9 +37,6 @@ type EvalDelta struct {
 
 	Logs []string `codec:"lg,allocbound=config.MaxLogCalls"`
 
-	// Intentionally, temporarily wrong - need to decide how to
-	// allocbound properly when structure is recursive.  Even a bound
-	// of 2 would allow arbitrarily large object if deep.
 	InnerTxns []SignedTxnWithAD `codec:"itx,allocbound=config.MaxInnerTransactions"`
 }
 

data/txHandler.go

@@ -502,6 +502,7 @@ func (handler *solicitedAsyncTxHandler) HandleTransactionGroups(networkPeer inte
 
 func (handler *solicitedAsyncTxHandler) Start() {
 	if handler.stopCtxFunc == nil {
+		handler.txHandler.Start()
 		var ctx context.Context
 		ctx, handler.stopCtxFunc = context.WithCancel(context.Background())
 		handler.stopped.Add(1)
@@ -514,6 +515,7 @@ func (handler *solicitedAsyncTxHandler) Stop() {
 		handler.stopCtxFunc()
 		handler.stopped.Wait()
 		handler.stopCtxFunc = nil
+		handler.txHandler.Stop()
 	}
 }
 

network/wsNetwork.go

@@ -1144,7 +1144,21 @@ func (wn *WebsocketNetwork) ServeHTTP(response http.ResponseWriter, request *htt
 
 	// We are careful to encode this prior to starting the server to avoid needing 'messagesOfInterestMu' here.
 	if wn.messagesOfInterestEnc != nil {
-		err = peer.Unicast(wn.ctx, wn.messagesOfInterestEnc, protocol.MsgOfInterestTag, nil)
+		msg := wn.messagesOfInterestEnc
+		// for older peers, we want to include also the "TX" message, for backward compatibility.
+		// this statement could be safely removed once we've fully migrated.
+		if peer.version == "2.1" {
+			wn.messagesOfInterestMu.Lock()
+			txSendMsgTags := make(map[protocol.Tag]bool)
+			for tag := range wn.messagesOfInterest {
+				txSendMsgTags[tag] = true
+			}
+			wn.messagesOfInterestMu.Unlock()
+			txSendMsgTags[protocol.TxnTag] = true
+			msg = MarshallMessageOfInterestMap(txSendMsgTags)
+		}
+		err = peer.Unicast(wn.ctx, msg, protocol.MsgOfInterestTag, nil)
+
 		if err != nil {
 			wn.log.Infof("ws send msgOfInterest: %v", err)
 		}

test/e2e-go/features/transactions/sendReceive_test.go

@@ -17,12 +17,14 @@
 package transactions
 
 import (
+	"fmt"
 	"math/rand"
 	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 
+	"github.com/algorand/go-algorand/config"
 	v1 "github.com/algorand/go-algorand/daemon/algod/api/spec/v1"
 	"github.com/algorand/go-algorand/test/framework/fixtures"
 	"github.com/algorand/go-algorand/test/partitiontest"
@@ -66,11 +68,16 @@ func TestDevModeAccountsCanSendMoney(t *testing.T) {
 
 func testAccountsCanSendMoney(t *testing.T, templatePath string, numberOfSends int) {
 	t.Parallel()
-	a := require.New(fixtures.SynchronizedTest(t))
 
 	var fixture fixtures.RestClientFixture
 	fixture.Setup(t, templatePath)
 	defer fixture.Shutdown()
+	testAccountsCanSendMoneyFixture(t, &fixture, numberOfSends)
+}
+
+func testAccountsCanSendMoneyFixture(t *testing.T, fixture *fixtures.RestClientFixture, numberOfSends int) {
+	a := require.New(fixtures.SynchronizedTest(t))
+
 	c := fixture.LibGoalClient
 
 	pingClient := fixture.LibGoalClient
@@ -159,3 +166,45 @@ func testAccountsCanSendMoney(t *testing.T, templatePath string, numberOfSends i
 	a.True(expectedPingBalance <= pingBalance, "ping balance is different than expected.")
 	a.True(expectedPongBalance <= pongBalance, "pong balance is different than expected.")
 }
+
+// this test checks that two accounts' balances stay up to date
+// as they send each other money many times
+func TestAccountsCanSendMoneyAcrossTxSync(t *testing.T) {
+	partitiontest.PartitionTest(t)
+	defer fixtures.ShutdownSynchronizedTest(t)
+
+	numberOfSends := 3
+	a := require.New(fixtures.SynchronizedTest(t))
+
+	networkProtocolVersions := []string{"3.0", "2.1"}
+
+	testMoneySending := func(t *testing.T, primaryNodeVersionIdx, nodeVersionIdx int) {
+		t.Run(fmt.Sprintf("%s->%s", networkProtocolVersions[primaryNodeVersionIdx], networkProtocolVersions[nodeVersionIdx]),
+			func(t *testing.T) {
+				t.Parallel()
+				var fixture fixtures.RestClientFixture
+				fixture.SetupNoStart(t, filepath.Join("nettemplates", "TwoNodes50Each.json"))
+				defer fixture.Shutdown()
+
+				cfg, err := config.LoadConfigFromDisk(fixture.PrimaryDataDir())
+				a.NoError(err)
+				cfg.NetworkProtocolVersion = networkProtocolVersions[primaryNodeVersionIdx]
+				cfg.SaveToDisk(fixture.PrimaryDataDir())
+
+				cfg, err = config.LoadConfigFromDisk(fixture.NodeDataDirs()[0])
+				a.NoError(err)
+				cfg.NetworkProtocolVersion = networkProtocolVersions[primaryNodeVersionIdx]
+				cfg.SaveToDisk(fixture.NodeDataDirs()[0])
+
+				fixture.Start()
+				testAccountsCanSendMoneyFixture(t, &fixture, numberOfSends)
+			})
+	}
+
+	// test to see that we can communicate correctly regardless of the network protocol version.
+	for primaryNodeVersionIdx := 0; primaryNodeVersionIdx < 2; primaryNodeVersionIdx++ {
+		for nodeVersionIdx := 0; nodeVersionIdx < 2; nodeVersionIdx++ {
+			testMoneySending(t, primaryNodeVersionIdx, nodeVersionIdx)
+		}
+	}
+}