Fix bytes.Clone

sc/memiavl/db/iterator.go

@@ -1,6 +1,9 @@
 package memiavl
 
-import "bytes"
+import (
+	"bytes"
+	"github.com/sei-protocol/sei-db/memiavl/utils"
+)
 
 type Iterator struct {
 	// domain of iteration, end is exclusive
@@ -51,15 +54,15 @@ func (iter *Iterator) Error() error {
 // Key implements dbm.Iterator
 func (iter *Iterator) Key() []byte {
 	if !iter.zeroCopy {
-		return bytes.Clone(iter.key)
+		return utils.Clone(iter.key)
 	}
 	return iter.key
 }
 
 // Value implements dbm.Iterator
 func (iter *Iterator) Value() []byte {
 	if !iter.zeroCopy {
-		return bytes.Clone(iter.value)
+		return utils.Clone(iter.value)
 	}
 	return iter.value
 }

sc/memiavl/db/persisted_node.go

@@ -3,6 +3,7 @@ package memiavl
 import (
 	"bytes"
 	"crypto/sha256"
+	"github.com/sei-protocol/sei-db/memiavl/utils"
 	"sort"
 )
 
@@ -132,7 +133,7 @@ func (node PersistedNode) Right() Node {
 }
 
 func (node PersistedNode) SafeHash() []byte {
-	return bytes.Clone(node.Hash())
+	return utils.Clone(node.Hash())
 }
 
 func (node PersistedNode) Hash() []byte {

sc/memiavl/db/tree.go

@@ -1,7 +1,6 @@
 package memiavl
 
 import (
-	"bytes"
 	"crypto/sha256"
 	"errors"
 	"fmt"
@@ -184,7 +183,7 @@ func (t *Tree) GetWithIndex(key []byte) (int64, []byte) {
 
 	value, index := t.root.Get(key)
 	if !t.zeroCopy {
-		value = bytes.Clone(value)
+		value = utils.Clone(value)
 	}
 	return int64(index), value
 }
@@ -199,8 +198,8 @@ func (t *Tree) GetByIndex(index int64) ([]byte, []byte) {
 
 	key, value := t.root.GetByIndex(uint32(index))
 	if !t.zeroCopy {
-		key = bytes.Clone(key)
-		value = bytes.Clone(value)
+		key = utils.Clone(key)
+		value = utils.Clone(value)
 	}
 	return key, value
 }

sc/memiavl/utils/bytes.go

@@ -0,0 +1,19 @@
+package utils
+
+// Clone returns a copy of b[:len(b)].
+// The result may have additional unused capacity.
+// Clone(nil) returns nil.
+func Clone(b []byte) []byte {
+	if b == nil {
+		return nil
+	}
+	return append([]byte{}, b...)
+}
+
+// Equal reports whether a and b
+// are the same length and contain the same bytes.
+// A nil argument is equivalent to an empty slice.
+func Equal(a, b []byte) bool {
+	// Neither cmd/compile nor gccgo allocates for these string conversions.
+	return string(a) == string(b)
+}

sc/memiavl/utils/bytes_test.go

@@ -0,0 +1,37 @@
+package utils
+
+import (
+	"strings"
+	"testing"
+	"unsafe"
+)
+
+func TestClone(t *testing.T) {
+	var cloneTests = [][]byte{
+		[]byte(nil),
+		[]byte{},
+		Clone([]byte{}),
+		[]byte(strings.Repeat("a", 42))[:0],
+		[]byte(strings.Repeat("a", 42))[:0:0],
+		[]byte("short"),
+		[]byte(strings.Repeat("a", 42)),
+	}
+	for _, input := range cloneTests {
+		clone := Clone(input)
+		if !Equal(clone, input) {
+			t.Errorf("Clone(%q) = %q; want %q", input, clone, input)
+		}
+
+		if input == nil && clone != nil {
+			t.Errorf("Clone(%#v) return value should be equal to nil slice.", input)
+		}
+
+		if input != nil && clone == nil {
+			t.Errorf("Clone(%#v) return value should not be equal to nil slice.", input)
+		}
+
+		if cap(input) != 0 && unsafe.SliceData(input) == unsafe.SliceData(clone) {
+			t.Errorf("Clone(%q) return value should not reference inputs backing memory.", input)
+		}
+	}
+}