Ignore last two invoke complexities ride v5

pkg/proto/transactions_test.go

@@ -5983,7 +5983,7 @@ func TestInvokeScriptWithProofsValidations(t *testing.T) {
 	repeat := func(arg StringArgument, n int) Arguments {
 		r := make([]Argument, n)
 		for i := 0; i < n; i++ {
-			r = append(r, arg)
+			r = append(r, &arg)
 		}
 		return r
 	}
@@ -6000,13 +6000,13 @@ func TestInvokeScriptWithProofsValidations(t *testing.T) {
 		err     string
 		version byte
 	}{
-		{ScriptPayments{}, "foo", Arguments{IntegerArgument{Value: 1234567890}}, 0, "fee should be positive", 1},
-		{ScriptPayments{{12345, *a1}}, "foo", Arguments{StringArgument{Value: "some value should be ok"}}, math.MaxInt64 + 1, "fee is too big", 1},
+		{ScriptPayments{}, "foo", Arguments{&IntegerArgument{Value: 1234567890}}, 0, "fee should be positive", 1},
+		{ScriptPayments{{12345, *a1}}, "foo", Arguments{&StringArgument{Value: "some value should be ok"}}, math.MaxInt64 + 1, "fee is too big", 1},
 		{ScriptPayments{{12345, *a1}}, strings.Repeat("foo", 100), Arguments{}, 13245, "function name is too big", 1},
 		{ScriptPayments{{12345, *a1}}, "foo", repeat(StringArgument{Value: "some value should be ok"}, 100), 13245, "too many arguments", 1},
-		{ScriptPayments{{0, *a1}}, "foo", Arguments{StringArgument{Value: "some value should be ok"}}, 1234, "at least one payment has a non-positive amount", 1},
-		{ScriptPayments{{math.MaxInt64 + 123, *a1}}, "foo", Arguments{StringArgument{Value: "some value should be ok"}}, 12345, "at least one payment has a too big amount", 1},
-		{ScriptPayments{}, "foo", Arguments{IntegerArgument{Value: 1234567890}}, 1, "unexpected version 128 for InvokeScriptWithProofs", 128},
+		{ScriptPayments{{0, *a1}}, "foo", Arguments{&StringArgument{Value: "some value should be ok"}}, 1234, "at least one payment has a non-positive amount", 1},
+		{ScriptPayments{{math.MaxInt64 + 123, *a1}}, "foo", Arguments{&StringArgument{Value: "some value should be ok"}}, 12345, "at least one payment has a too big amount", 1},
+		{ScriptPayments{}, "foo", Arguments{&IntegerArgument{Value: 1234567890}}, 1, "unexpected version 128 for InvokeScriptWithProofs", 128},
 		//TODO: add test on arguments evaluation
 	}
 	for _, tc := range tests {

pkg/proto/types.go

@@ -3189,16 +3189,16 @@ func NewIntegerArgument(i int64) *IntegerArgument {
 }
 
 //GetValueType returns the value type of the entry.
-func (a IntegerArgument) GetValueType() ArgumentValueType {
+func (a *IntegerArgument) GetValueType() ArgumentValueType {
 	return ArgumentInteger
 }
 
-func (a IntegerArgument) BinarySize() int {
+func (a *IntegerArgument) BinarySize() int {
 	return integerArgumentLen
 }
 
 //MarshalBinary marshals the integer argument in its bytes representation.
-func (a IntegerArgument) MarshalBinary() ([]byte, error) {
+func (a *IntegerArgument) MarshalBinary() ([]byte, error) {
 	buf := make([]byte, a.BinarySize())
 	pos := 0
 	buf[pos] = byte(ArgumentInteger)
@@ -3208,7 +3208,7 @@ func (a IntegerArgument) MarshalBinary() ([]byte, error) {
 }
 
 //Serialize the integer argument in its bytes representation.
-func (a IntegerArgument) Serialize(s *serializer.Serializer) error {
+func (a *IntegerArgument) Serialize(s *serializer.Serializer) error {
 	err := s.Byte(byte(ArgumentInteger))
 	if err != nil {
 		return err
@@ -3255,16 +3255,16 @@ type BooleanArgument struct {
 }
 
 //GetValueType returns the data type (Boolean) of the argument.
-func (a BooleanArgument) GetValueType() ArgumentValueType {
+func (a *BooleanArgument) GetValueType() ArgumentValueType {
 	return ArgumentBoolean
 }
 
-func (a BooleanArgument) BinarySize() int {
+func (a *BooleanArgument) BinarySize() int {
 	return booleanArgumentLen
 }
 
 //MarshalBinary writes a byte representation of the boolean data entry.
-func (a BooleanArgument) MarshalBinary() ([]byte, error) {
+func (a *BooleanArgument) MarshalBinary() ([]byte, error) {
 	buf := make([]byte, a.BinarySize())
 	if a.Value {
 		buf[0] = byte(ArgumentValueTrue)
@@ -3275,7 +3275,7 @@ func (a BooleanArgument) MarshalBinary() ([]byte, error) {
 }
 
 //Serialize argument to its byte representation.
-func (a BooleanArgument) Serialize(s *serializer.Serializer) error {
+func (a *BooleanArgument) Serialize(s *serializer.Serializer) error {
 	buf := byte(0)
 	if a.Value {
 		buf = byte(ArgumentValueTrue)
@@ -3328,16 +3328,16 @@ type BinaryArgument struct {
 }
 
 //GetValueType returns the type of value (Binary) stored in an argument.
-func (a BinaryArgument) GetValueType() ArgumentValueType {
+func (a *BinaryArgument) GetValueType() ArgumentValueType {
 	return ArgumentBinary
 }
 
-func (a BinaryArgument) BinarySize() int {
+func (a *BinaryArgument) BinarySize() int {
 	return binaryArgumentMinLen + len(a.Value)
 }
 
 //MarshalBinary writes an argument to its byte representation.
-func (a BinaryArgument) MarshalBinary() ([]byte, error) {
+func (a *BinaryArgument) MarshalBinary() ([]byte, error) {
 	buf := make([]byte, a.BinarySize())
 	pos := 0
 	buf[pos] = byte(ArgumentBinary)
@@ -3347,7 +3347,7 @@ func (a BinaryArgument) MarshalBinary() ([]byte, error) {
 }
 
 //Serialize argument to its byte representation.
-func (a BinaryArgument) Serialize(s *serializer.Serializer) error {
+func (a *BinaryArgument) Serialize(s *serializer.Serializer) error {
 	err := s.Byte(byte(ArgumentBinary))
 	if err != nil {
 		return err
@@ -3402,16 +3402,16 @@ func NewStringArgument(s string) *StringArgument {
 }
 
 //GetValueType returns the type of value of the argument.
-func (a StringArgument) GetValueType() ArgumentValueType {
+func (a *StringArgument) GetValueType() ArgumentValueType {
 	return ArgumentString
 }
 
-func (a StringArgument) BinarySize() int {
+func (a *StringArgument) BinarySize() int {
 	return stringArgumentMinLen + len(a.Value)
 }
 
 //MarshalBinary converts the argument to its byte representation.
-func (a StringArgument) MarshalBinary() ([]byte, error) {
+func (a *StringArgument) MarshalBinary() ([]byte, error) {
 	buf := make([]byte, a.BinarySize())
 	pos := 0
 	buf[pos] = byte(ArgumentString)
@@ -3421,7 +3421,7 @@ func (a StringArgument) MarshalBinary() ([]byte, error) {
 }
 
 //Serialize argument to its byte representation.
-func (a StringArgument) Serialize(s *serializer.Serializer) error {
+func (a *StringArgument) Serialize(s *serializer.Serializer) error {
 	err := s.Byte(byte(ArgumentString))
 	if err != nil {
 		return err
@@ -3471,16 +3471,16 @@ type ListArgument struct {
 }
 
 //GetValueType returns the type of value of the argument.
-func (a ListArgument) GetValueType() ArgumentValueType {
+func (a *ListArgument) GetValueType() ArgumentValueType {
 	return ArgumentList
 }
 
-func (a ListArgument) BinarySize() int {
+func (a *ListArgument) BinarySize() int {
 	return 1 + a.Items.BinarySize()
 }
 
 //MarshalBinary converts the argument to its byte representation.
-func (a ListArgument) MarshalBinary() ([]byte, error) {
+func (a *ListArgument) MarshalBinary() ([]byte, error) {
 	buf := make([]byte, a.BinarySize())
 	pos := 0
 	buf[pos] = byte(ArgumentList)
@@ -3494,7 +3494,7 @@ func (a ListArgument) MarshalBinary() ([]byte, error) {
 }
 
 //Serialize argument to its byte representation.
-func (a ListArgument) Serialize(s *serializer.Serializer) error {
+func (a *ListArgument) Serialize(s *serializer.Serializer) error {
 	err := s.Byte(byte(ArgumentList))
 	if err != nil {
 		return err

pkg/ride/environment.go

@@ -13,6 +13,13 @@ var (
 	errDeletedEntry = errors.New("entry has been deleted")
 )
 
+var (
+	libV2CheckMessageLength = func(int) bool { return true }
+	libV3CheckMessageLength = func(l int) bool {
+		return l <= maxMessageLength
+	}
+)
+
 type WrappedState struct {
 	diff                      diffState
 	cle                       rideAddress
@@ -943,6 +950,7 @@ type EvaluationEnvironment struct {
 	ver                   ast.LibraryVersion
 	validatePaymentsAfter uint64
 	isBlockV5Activated    bool
+	isRiveV5Activated     bool
 	isRiveV6Activated     bool
 	isProtobufTransaction bool
 	mds                   int
@@ -957,7 +965,7 @@ func NewEnvironment(scheme proto.Scheme, state types.SmartState, internalPayment
 		sch:                   scheme,
 		st:                    state,
 		h:                     rideInt(height),
-		check:                 func(int) bool { return true }, // By default, for versions below 2 there was no check, always ok.
+		check:                 libV2CheckMessageLength, // By default, for versions below 2 there was no check, always ok.
 		takeStr:               func(s string, n int) rideString { panic("function 'takeStr' was not initialized") },
 		validatePaymentsAfter: internalPaymentsValidationHeight,
 	}, nil
@@ -968,6 +976,7 @@ func NewEnvironmentWithWrappedState(
 	payments proto.ScriptPayments,
 	sender proto.WavesAddress,
 	isBlockV5Activated bool,
+	isRideV5Activated bool,
 	isRideV6Activated bool,
 	isProtobufTransaction bool,
 	rootScriptLibVersion ast.LibraryVersion,
@@ -1040,6 +1049,7 @@ func NewEnvironmentWithWrappedState(
 		validatePaymentsAfter: env.validatePaymentsAfter,
 		mds:                   env.mds,
 		isBlockV5Activated:    isBlockV5Activated,
+		isRiveV5Activated:     isRideV5Activated,
 		isRiveV6Activated:     isRideV6Activated,
 		isProtobufTransaction: isProtobufTransaction,
 	}, nil
@@ -1049,6 +1059,10 @@ func (e *EvaluationEnvironment) rideV6Activated() bool {
 	return e.isRiveV6Activated
 }
 
+func (e *EvaluationEnvironment) rideV5Activated() bool {
+	return e.isRiveV5Activated
+}
+
 func (e *EvaluationEnvironment) blockV5Activated() bool {
 	return e.isBlockV5Activated
 }
@@ -1063,9 +1077,7 @@ func (e *EvaluationEnvironment) ChooseTakeString(isRideV5 bool) {
 func (e *EvaluationEnvironment) ChooseSizeCheck(v ast.LibraryVersion) {
 	e.ver = v
 	if v > ast.LibV2 {
-		e.check = func(l int) bool {
-			return l <= maxMessageLength
-		}
+		e.check = libV3CheckMessageLength
 	}
 }
 

pkg/ride/errors.go

@@ -21,17 +21,13 @@ type evaluationError struct {
 	originalError   error
 	callStack       []string
 	spentComplexity int
+	complexities    []int
 }
 
 func (e evaluationError) Error() string {
 	return e.originalError.Error()
 }
 
-func (e evaluationError) AddComplexity(complexity int) error {
-	e.spentComplexity += complexity
-	return e
-}
-
 func (e EvaluationError) New(msg string) error {
 	return evaluationError{errorType: e, originalError: errors.New(msg)}
 }
@@ -62,6 +58,13 @@ func EvaluationErrorCallStack(err error) []string {
 	return nil
 }
 
+func EvaluationErrorReverseComplexitiesList(err error) []int {
+	if ee, ok := err.(evaluationError); ok {
+		return ee.complexities
+	}
+	return nil
+}
+
 func EvaluationErrorSpentComplexity(err error) int {
 	if ee, ok := err.(evaluationError); ok {
 		return ee.spentComplexity
@@ -71,12 +74,27 @@ func EvaluationErrorSpentComplexity(err error) int {
 
 func EvaluationErrorPush(err error, format string, args ...interface{}) error {
 	if ee, ok := err.(evaluationError); ok {
-		ee.callStack = append([]string{fmt.Sprintf(format, args...)}, ee.callStack...)
+		elem := fmt.Sprintf(format, args...)
+		if cap(ee.callStack) > len(ee.callStack) { // reusing the same memory area
+			ee.callStack = append(ee.callStack[:1], ee.callStack...)
+			ee.callStack[0] = elem
+		} else { // allocating memory
+			ee.callStack = append([]string{elem}, ee.callStack...)
+		}
 		return ee
 	}
 	return errors.Wrapf(err, format, args...)
 }
 
+func EvaluationErrorPushComplexity(err error, complexity int) error {
+	if ee, ok := err.(evaluationError); ok {
+		ee.complexities = append(ee.complexities, complexity)
+		ee.spentComplexity += complexity
+		return ee
+	}
+	return err
+}
+
 func EvaluationErrorAddComplexity(err error, complexity int) error {
 	if ee, ok := err.(evaluationError); ok {
 		ee.spentComplexity += complexity