Check array element count before inserting new element

This commit checks if the array element count reached the max limit
(currently math.MaxUint32) before inserting a new element to the array.

If the array already has the max number of elements allowed (4.29+ billion)
then the insert function returns a user error.

NOTE: Even before adding this check, a single transaction cannot by itself
insert 4.29+ billion elements due to various transaction limits enforced
by client software (onflow/cadence and onflow/flow-go).

Author: fxamacker

array.go

@@ -20,9 +20,19 @@ package atree
 
 import (
 	"fmt"
+	"math"
 	"strings"
 )
 
+const (
+	// maxArrayElementCount is the max number of elements that can be stored in an array.
+	// Currently, this limit is set to math.MaxUint32 (4,294,967,295 elements per array).
+	// ArraySlabHeader.Count (uint32) is used to track element count in array slabs.
+	// NOTE: MaxArrayElementCount is uint64 since we may want to increase the limit to be
+	// greater than MaxUint32 in the future.
+	maxArrayElementCount uint64 = math.MaxUint32
+)
+
 // Array is a heterogeneous variable-size array, storing any type of values
 // into a smaller ordered list of values and provides efficient functionality
 // to lookup, insert and remove elements anywhere in the array.
@@ -444,6 +454,11 @@ func (a *Array) Append(value Value) error {
 }
 
 func (a *Array) Insert(index uint64, value Value) error {
+	if a.Count() == maxArrayElementCount {
+		// Don't insert new element if array already has max number of elements.
+		return NewArrayElementCannotExceedMaxElementCountError(maxArrayElementCount)
+	}
+
 	err := a.root.Insert(a.Storage, a.Address(), index, value)
 	if err != nil {
 		// Don't need to wrap error as external error because err is already categorized by ArraySlab.Insert().

errors.go

@@ -76,6 +76,25 @@ func (e *FatalError) Unwrap() error {
 	return e.err
 }
 
+// ArrayElementCannotExceedMaxElementCountError is returned when new element can't be inserted into an array
+// because the array already has the max number of elements allowed.
+type ArrayElementCannotExceedMaxElementCountError struct {
+	maxCount uint64
+}
+
+// NewArrayElementCannotExceedMaxElementCountError returns ArrayElementCannotExceedMaxElementCountError.
+func NewArrayElementCannotExceedMaxElementCountError(maxCount uint64) error {
+	return NewUserError(
+		&ArrayElementCannotExceedMaxElementCountError{
+			maxCount: maxCount,
+		},
+	)
+}
+
+func (e *ArrayElementCannotExceedMaxElementCountError) Error() string {
+	return fmt.Sprintf("new element cann't be inserted into an array: array already has max number of elements %d", e.maxCount)
+}
+
 // SliceOutOfBoundsError is returned when index for array slice is out of bounds.
 type SliceOutOfBoundsError struct {
 	startIndex uint64