Impose limits on reading and writing of box bytes

Author: jannotti

cmd/goal/application.go

@@ -359,7 +359,7 @@ func translateBoxRefs(input []boxRef, foreignApps []uint64) []transactions.BoxRe
 		}
 		output[i] = transactions.BoxRef{
 			Index: index,
-			Name:  string(rawName),
+			Name:  rawName,
 		}
 	}
 	return output

config/consensus.go

@@ -342,7 +342,14 @@ type ConsensusParams struct {
 	BoxByteMinBalance uint64
 
 	// Number of box references allowed
-	MaxAppBoxReferences uint64
+	MaxAppBoxReferences int
+
+	// Amount added to a txgroup's box I/O budget per box ref supplied.
+	// For reads: the sum of the sizes of all boxes in the group must be less than I/O budget
+	// For writes: the sum of the sizes of all boxes created or written must be less than I/O budget
+	// In both cases, what matters is the sizes of the boxes touched, not the
+	// number of times they are touched, or the size of the touches.
+	BytesPerBoxReference uint64
 
 	// maximum number of total key/value pairs allowed by a given
 	// LocalStateSchema (and therefore allowed in LocalState)
@@ -1163,10 +1170,11 @@ func initConsensusProtocols() {
 	vFuture.EnableSHA256TxnCommitmentHeader = true
 
 	// Boxes (unlimited global storage)
-	vFuture.MaxBoxSize = 8096
-	vFuture.BoxFlatMinBalance = 2500
-	vFuture.BoxByteMinBalance = 400
+	vFuture.MaxBoxSize = 4 * 8096
+	vFuture.BoxFlatMinBalance = 10000
+	vFuture.BoxByteMinBalance = 350
 	vFuture.MaxAppBoxReferences = 8
+	vFuture.BytesPerBoxReference = 8096
 
 	Consensus[protocol.ConsensusFuture] = vFuture
 }

data/transactions/application.go

@@ -122,7 +122,7 @@ type ApplicationCallTxnFields struct {
 	ForeignApps []basics.AppIndex `codec:"apfa,allocbound=encodedMaxForeignApps"`
 
 	// Boxes are the boxes that can be accessed by this transaction (and others
-	// in the same group). The Index in the boxRef is the slot of ForeignApps
+	// in the same group). The Index in the BoxRef is the slot of ForeignApps
 	// that the name is asscoiated with (shifted by 1, so 0 indicates "current
 	// app")
 	Boxes []BoxRef `codec:"apbx,allocbound=encodedMaxBoxes"`
@@ -172,7 +172,7 @@ type BoxRef struct {
 	_struct struct{} `codec:",omitempty,omitemptyarray"`
 
 	Index uint64 `codec:"i"`
-	Name  string `codec:"n"`
+	Name  []byte `codec:"n"`
 }
 
 // Empty indicates whether or not all the fields in the

data/transactions/json.go

@@ -16,6 +16,12 @@
 
 package transactions_test
 
+/* These tests are pretty low-value now.  They test something very basic about
+   our codec for encoding []byte as base64 strings in json. The test were
+   written we BoxRef contained a string instead of []byte.  When that was true,
+   these tests were more important because there was work that had to be done to
+   make it happen (implement MarshalJSON and UnmarshalJSON) */
+
 import (
 	"strings"
 	"testing"
@@ -41,16 +47,16 @@ func compact(data []byte) string {
 
 // TestJsonMarshal ensures that BoxRef names are b64 encoded, since they may not be characters.
 func TestJsonMarshal(t *testing.T) {
-	marshal := protocol.EncodeJSON(transactions.BoxRef{Index: 4, Name: "joe"})
+	marshal := protocol.EncodeJSON(transactions.BoxRef{Index: 4, Name: []byte("joe")})
 	require.Equal(t, `{"i":4,"n":"am9l"}`, compact(marshal))
 
-	marshal = protocol.EncodeJSON(transactions.BoxRef{Index: 0, Name: "joe"})
+	marshal = protocol.EncodeJSON(transactions.BoxRef{Index: 0, Name: []byte("joe")})
 	require.Equal(t, `{"n":"am9l"}`, compact(marshal))
 
-	marshal = protocol.EncodeJSON(transactions.BoxRef{Index: 1, Name: ""})
+	marshal = protocol.EncodeJSON(transactions.BoxRef{Index: 1, Name: []byte("")})
 	require.Equal(t, `{"i":1}`, compact(marshal))
 
-	marshal = protocol.EncodeJSON(transactions.BoxRef{Index: 0, Name: ""})
+	marshal = protocol.EncodeJSON(transactions.BoxRef{Index: 0, Name: []byte("")})
 	require.Equal(t, `{}`, compact(marshal))
 }
 
@@ -59,16 +65,19 @@ func TestJsonUnmarshal(t *testing.T) {
 	var br transactions.BoxRef
 
 	decode(`{"i":4,"n":"am9l"}`, &br)
-	require.Equal(t, transactions.BoxRef{Index: 4, Name: "joe"}, br)
+	require.Equal(t, transactions.BoxRef{Index: 4, Name: []byte("joe")}, br)
 
+	br = transactions.BoxRef{}
 	decode(`{"n":"am9l"}`, &br)
-	require.Equal(t, transactions.BoxRef{Index: 0, Name: "joe"}, br)
+	require.Equal(t, transactions.BoxRef{Index: 0, Name: []byte("joe")}, br)
 
+	br = transactions.BoxRef{}
 	decode(`{"i":4}`, &br)
-	require.Equal(t, transactions.BoxRef{Index: 4, Name: ""}, br)
+	require.Equal(t, transactions.BoxRef{Index: 4, Name: nil}, br)
 
+	br = transactions.BoxRef{}
 	decode(`{}`, &br)
-	require.Equal(t, transactions.BoxRef{Index: 0, Name: ""}, br)
+	require.Equal(t, transactions.BoxRef{Index: 0, Name: nil}, br)
 }
 
 // TestTxnJson tests a few more things about how our Transactions get JSON
@@ -82,7 +91,7 @@ func TestTxnJson(t *testing.T) {
 	require.Contains(t, compact(marshal), `"snd":"AEBA`)
 
 	txn = txntest.Txn{
-		Boxes: []transactions.BoxRef{{Index: 3, Name: "john"}},
+		Boxes: []transactions.BoxRef{{Index: 3, Name: []byte("john")}},
 	}
 	marshal = protocol.EncodeJSON(txn.Txn())
 	require.Contains(t, compact(marshal), `"apbx":[{"i":3,"n":"am9obg=="}]`)

data/transactions/json_test.go

@@ -452,7 +452,7 @@ func (ops *OpStream) ByteLiteral(val []byte) {
 
 func asmInt(ops *OpStream, spec *OpSpec, args []string) error {
 	if len(args) != 1 {
-		return ops.error("int needs one argument")
+		return ops.errorf("%s needs one immediate argument, was given %d", spec.Name, len(args))
 	}
 	// check txn type constants
 	i, ok := txnTypeMap[args[0]]
@@ -477,7 +477,7 @@ func asmInt(ops *OpStream, spec *OpSpec, args []string) error {
 // Explicit invocation of const lookup and push
 func asmIntC(ops *OpStream, spec *OpSpec, args []string) error {
 	if len(args) != 1 {
-		return ops.error("intc operation needs one argument")
+		return ops.errorf("%s needs one immediate argument, was given %d", spec.Name, len(args))
 	}
 	constIndex, err := simpleImm(args[0], "constant")
 	if err != nil {
@@ -488,7 +488,7 @@ func asmIntC(ops *OpStream, spec *OpSpec, args []string) error {
 }
 func asmByteC(ops *OpStream, spec *OpSpec, args []string) error {
 	if len(args) != 1 {
-		return ops.error("bytec operation needs one argument")
+		return ops.errorf("%s needs one immediate argument, was given %d", spec.Name, len(args))
 	}
 	constIndex, err := simpleImm(args[0], "constant")
 	if err != nil {
@@ -500,7 +500,7 @@ func asmByteC(ops *OpStream, spec *OpSpec, args []string) error {
 
 func asmPushInt(ops *OpStream, spec *OpSpec, args []string) error {
 	if len(args) != 1 {
-		return ops.errorf("%s needs one argument", spec.Name)
+		return ops.errorf("%s needs one immediate argument, was given %d", spec.Name, len(args))
 	}
 	val, err := strconv.ParseUint(args[0], 0, 64)
 	if err != nil {
@@ -514,14 +514,14 @@ func asmPushInt(ops *OpStream, spec *OpSpec, args []string) error {
 }
 func asmPushBytes(ops *OpStream, spec *OpSpec, args []string) error {
 	if len(args) == 0 {
-		return ops.errorf("%s operation needs byte literal argument", spec.Name)
+		return ops.errorf("%s needs byte literal argument", spec.Name)
 	}
 	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)
+		return ops.errorf("%s with extraneous argument", spec.Name)
 	}
 	ops.pending.WriteByte(spec.Opcode)
 	var scratch [binary.MaxVarintLen64]byte
@@ -680,14 +680,14 @@ func parseStringLiteral(input string) (result []byte, err error) {
 // byte "this is a string\n"
 func asmByte(ops *OpStream, spec *OpSpec, args []string) error {
 	if len(args) == 0 {
-		return ops.errorf("%s operation needs byte literal argument", spec.Name)
+		return ops.errorf("%s needs byte literal argument", spec.Name)
 	}
 	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)
+		return ops.errorf("%s with extraneous argument", spec.Name)
 	}
 	ops.ByteLiteral(val)
 	return nil
@@ -773,7 +773,7 @@ func asmByteCBlock(ops *OpStream, spec *OpSpec, args []string) error {
 // parses base32-with-checksum account address strings into a byte literal
 func asmAddr(ops *OpStream, spec *OpSpec, args []string) error {
 	if len(args) != 1 {
-		return ops.error("addr operation needs one argument")
+		return ops.errorf("%s needs one immediate argument, was given %d", spec.Name, len(args))
 	}
 	addr, err := basics.UnmarshalChecksumAddress(args[0])
 	if err != nil {
@@ -785,7 +785,7 @@ func asmAddr(ops *OpStream, spec *OpSpec, args []string) error {
 
 func asmArg(ops *OpStream, spec *OpSpec, args []string) error {
 	if len(args) != 1 {
-		return ops.error("arg operation needs one argument")
+		return ops.errorf("%s needs one immediate argument, was given %d", spec.Name, len(args))
 	}
 	val, err := simpleImm(args[0], "argument")
 	if err != nil {
@@ -810,7 +810,7 @@ func asmArg(ops *OpStream, spec *OpSpec, args []string) error {
 
 func asmBranch(ops *OpStream, spec *OpSpec, args []string) error {
 	if len(args) != 1 {
-		return ops.error("branch operation needs label argument")
+		return ops.errorf("%s needs a single label argument", spec.Name)
 	}
 
 	ops.referToLabel(ops.pending.Len(), args[0])

data/transactions/logic/assembler.go

@@ -763,8 +763,8 @@ func TestAssembleBytes(t *testing.T) {
 	expectedOptimizedConsts := "018006616263646566"
 
 	bad := [][]string{
-		{"byte", "...operation needs byte literal argument"},
-		{`byte "john" "doe"`, "...operation with extraneous argument"},
+		{"byte", "...needs byte literal argument"},
+		{`byte "john" "doe"`, "...with extraneous argument"},
 	}
 
 	for v := uint64(1); v <= AssemblerMaxVersion; v++ {
@@ -1543,17 +1543,40 @@ func TestConstantArgs(t *testing.T) {
 	t.Parallel()
 
 	for v := uint64(1); v <= AssemblerMaxVersion; v++ {
-		testProg(t, "int", v, Expect{1, "int needs one argument"})
-		testProg(t, "intc", v, Expect{1, "intc operation needs one argument"})
-		testProg(t, "byte", v, Expect{1, "byte operation needs byte literal argument"})
-		testProg(t, "bytec", v, Expect{1, "bytec operation needs one argument"})
-		testProg(t, "addr", v, Expect{1, "addr operation needs one argument"})
+		testProg(t, "int", v, Expect{1, "int needs one immediate argument, was given 0"})
+		testProg(t, "int 1 2", v, Expect{1, "int needs one immediate argument, was given 2"})
+		testProg(t, "intc", v, Expect{1, "intc needs one immediate argument, was given 0"})
+		testProg(t, "intc hi bye", v, Expect{1, "intc needs one immediate argument, was given 2"})
+		testProg(t, "byte", v, Expect{1, "byte needs byte literal argument"})
+		testProg(t, "bytec", v, Expect{1, "bytec needs one immediate argument, was given 0"})
+		testProg(t, "bytec 1 x", v, Expect{1, "bytec needs one immediate argument, was given 2"})
+		testProg(t, "addr", v, Expect{1, "addr needs one immediate argument, was given 0"})
+		testProg(t, "addr x y", v, Expect{1, "addr needs one immediate argument, was given 2"})
 	}
 	for v := uint64(3); v <= AssemblerMaxVersion; v++ {
-		testProg(t, "pushint", v, Expect{1, "pushint needs one argument"})
-		testProg(t, "pushbytes", v, Expect{1, "pushbytes operation needs byte literal argument"})
+		testProg(t, "pushint", v, Expect{1, "pushint needs one immediate argument, was given 0"})
+		testProg(t, "pushint 3 4", v, Expect{1, "pushint needs one immediate argument, was given 2"})
+		testProg(t, "pushbytes", v, Expect{1, "pushbytes needs byte literal argument"})
 	}
+}
+
+func TestBranchArgs(t *testing.T) {
+	partitiontest.PartitionTest(t)
+	t.Parallel()
 
+	for v := uint64(2); v <= AssemblerMaxVersion; v++ {
+		testProg(t, "b", v, Expect{1, "b needs a single label argument"})
+		testProg(t, "b lab1 lab2", v, Expect{1, "b needs a single label argument"})
+		testProg(t, "int 1; bz", v, Expect{2, "bz needs a single label argument"})
+		testProg(t, "int 1; bz a b", v, Expect{2, "bz needs a single label argument"})
+		testProg(t, "int 1; bnz", v, Expect{2, "bnz needs a single label argument"})
+		testProg(t, "int 1; bnz c d", v, Expect{2, "bnz needs a single label argument"})
+	}
+
+	for v := uint64(4); v <= AssemblerMaxVersion; v++ {
+		testProg(t, "callsub", v, Expect{1, "callsub needs a single label argument"})
+		testProg(t, "callsub one two", v, Expect{1, "callsub needs a single label argument"})
+	}
 }
 
 func TestAssembleDisassembleErrors(t *testing.T) {