fix: adding Sanitize() method to Data interface

schema/data/base/accAddressData.go

@@ -30,6 +30,12 @@ func (accAddressData accAddressData) Compare(listable traits.Listable) int {
 	if err != nil {
 		panic(err)
 	}
+	if sanitizedAccAddressData, err := accAddressData.Sanitize(); err != nil {
+		accAddressData.Value = sanitizedAccAddressData.(data.AccAddressData).Get()
+	}
+	if sanitizedCompareAccAddressData, err := compareAccAddressData.Sanitize(); err != nil {
+		compareAccAddressData.Value = sanitizedCompareAccAddressData.(data.AccAddressData).Get()
+	}
 
 	return bytes.Compare(accAddressData.Value.Bytes(), compareAccAddressData.Value.Bytes())
 }
@@ -56,6 +62,13 @@ func (accAddressData accAddressData) Get() sdkTypes.AccAddress {
 	return accAddressData.Value
 }
 
+func (accAddressData accAddressData) Sanitize() (data.Data, error) {
+	if accAddressData.Value.Empty() {
+		return accAddressData.ZeroValue(), nil
+	}
+	return accAddressData, nil
+}
+
 func accAddressDataFromInterface(listable traits.Listable) (accAddressData, error) {
 	switch value := listable.(type) {
 	case accAddressData:

schema/data/base/accAddressData_test.go

@@ -85,6 +85,8 @@ func Test_accAddressData_Compare(t *testing.T) {
 		args   args
 		want   int
 	}{
+		{"-ve nil", fields{}, args{NewAccAddressData(nil)}, 0},
+		{"+ve with nil", fields{types.AccAddress{}}, args{NewAccAddressData(nil)}, 0},
 		{"-ve empty String", fields{fromAccAddress}, args{accAddressData{}}, 1},
 		{"+ve", fields{fromAccAddress}, args{accAddressData{fromAccAddress}}, 0},
 	}

schema/data/base/booleanData.go

@@ -64,6 +64,10 @@ func (booleanData booleanData) Get() bool {
 	return booleanData.Value
 }
 
+func (booleanData booleanData) Sanitize() (data.Data, error) {
+	return booleanData, nil
+}
+
 func booleanDataFromInterface(listable traits.Listable) (booleanData, error) {
 	switch value := listable.(type) {
 	case booleanData:

schema/data/base/booleanData_test.go

@@ -35,31 +35,6 @@ func TestNewBooleanData(t *testing.T) {
 	}
 }
 
-func TestBooleanDataFromInterface(t *testing.T) {
-	type args struct {
-		dataString data.Data
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    data.Data
-		wantErr assert.ErrorAssertionFunc
-	}{
-		{"-ve", args{NewBooleanData(false)}, booleanData{false}, assert.NoError},
-		{"+ve", args{NewBooleanData(true)}, booleanData{true}, assert.NoError},
-		{"-ve", args{NewStringData("test")}, booleanData{false}, assert.Error},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := booleanDataFromInterface(tt.args.dataString)
-			if !tt.wantErr(t, err, fmt.Sprintf("booleanDataFromInterface(%v)", tt.args.dataString)) {
-				return
-			}
-			assert.Equalf(t, tt.want, got, "booleanDataFromInterface(%v)", tt.args.dataString)
-		})
-	}
-}
-
 func Test_booleanDataFromInterface(t *testing.T) {
 	type args struct {
 		listable traits.Listable
@@ -99,6 +74,7 @@ func Test_booleanData_Compare(t *testing.T) {
 		args   args
 		want   int
 	}{
+		{"+ve with nil", fields{}, args{booleanData{}}, 0},
 		{"+ve", fields{false}, args{booleanData{true}}, -1},
 		{"+ve", fields{true}, args{booleanData{false}}, 1},
 		{"+ve", fields{false}, args{booleanData{false}}, 0},

schema/data/base/decData.go

@@ -29,6 +29,13 @@ func (decData decData) Compare(listable traits.Listable) int {
 		panic(err)
 	}
 
+	if sanitizedDecData, err := decData.Sanitize(); err != nil {
+		decData.Value = sanitizedDecData.(data.DecData).Get()
+	}
+	if sanitizedDecData, err := compareDecData.Sanitize(); err != nil {
+		compareDecData.Value = sanitizedDecData.(data.DecData).Get()
+	}
+
 	if decData.Value.GT(compareDecData.Value) {
 		return 1
 	} else if decData.Value.LT(compareDecData.Value) {
@@ -41,6 +48,9 @@ func (decData decData) String() string {
 	return decData.Value.String()
 }
 func (decData decData) Bytes() []byte {
+	if sanitizedDecData, err := decData.Sanitize(); err != nil {
+		decData.Value = sanitizedDecData.(data.DecData).Get()
+	}
 	return decData.Value.Bytes()
 }
 func (decData decData) GetType() ids.StringID {
@@ -60,6 +70,13 @@ func (decData decData) Get() sdkTypes.Dec {
 	return decData.Value
 }
 
+func (decData decData) Sanitize() (data.Data, error) {
+	if decData.Value.Int == nil {
+		return decData.ZeroValue(), constants.MetaDataError
+	}
+	return decData, nil
+}
+
 func decDataFromInterface(listable traits.Listable) (decData, error) {
 	switch value := listable.(type) {
 	case decData:

schema/data/base/decData_test.go

@@ -203,11 +203,7 @@ func Test_decData_GetID(t *testing.T) {
 			decData := decData{
 				Value: tt.fields.Value,
 			}
-			if tt.wantPanic {
-				require.Panics(t, func() {
-					decData.GetID()
-				})
-			} else if got := decData.GetID(); !reflect.DeepEqual(got, tt.want) {
+			if got := decData.GetID(); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("GetID() = %v, want %v", got, tt.want)
 			}
 		})

schema/data/base/heightData.go

@@ -32,6 +32,13 @@ func (heightData heightData) Compare(listable traits.Listable) int {
 		panic(err)
 	}
 
+	if sanitizedHeightData, err := heightData.Sanitize(); err != nil {
+		heightData.Value = sanitizedHeightData.(data.HeightData).Get()
+	}
+	if sanitizedCompareHeightData, err := compareHeightData.Sanitize(); err != nil {
+		compareHeightData.Value = sanitizedCompareHeightData.(data.HeightData).Get()
+	}
+
 	return heightData.Value.Compare(compareHeightData.Value)
 }
 func (heightData heightData) String() string {
@@ -56,9 +63,19 @@ func (heightData heightData) GenerateHashID() ids.HashID {
 	return baseIDs.GenerateHashID(heightData.Bytes())
 }
 func (heightData heightData) Get() types.Height {
+	if sanitizedHeightData, err := heightData.Sanitize(); err != nil {
+		return sanitizedHeightData.(data.HeightData).Get()
+	}
 	return heightData.Value
 }
 
+func (heightData heightData) Sanitize() (data.Data, error) {
+	if heightData.Value == nil {
+		return heightData.ZeroValue(), constants.MetaDataError
+	}
+	return heightData, nil
+}
+
 func heightDataFromInterface(listable traits.Listable) (heightData, error) {
 	switch value := listable.(type) {
 	case heightData:

schema/data/base/heightData_test.go

@@ -92,7 +92,7 @@ func Test_heightData_Compare(t *testing.T) {
 		args   args
 		want   int
 	}{
-
+		{"+ve with nil", fields{}, args{heightData{}}, 0},
 		{"Test for Equal case", fields{baseTypes.NewHeight(100)}, args{heightData{baseTypes.NewHeight(100)}}, 0},
 		{"Test for LT case", fields{baseTypes.NewHeight(0)}, args{heightData{baseTypes.NewHeight(100)}}, -1},
 		{"Test for GT case", fields{baseTypes.NewHeight(100)}, args{heightData{baseTypes.NewHeight(0)}}, 1},
@@ -118,7 +118,7 @@ func Test_heightData_GenerateHashID(t *testing.T) {
 		fields fields
 		want   ids.HashID
 	}{
-
+		{"+ve with nil", fields{}, baseIDs.GenerateHashID()},
 		{"Test for zero value", fields{baseTypes.NewHeight(-1)}, baseIDs.GenerateHashID()},
 		{"Test for -ve value", fields{baseTypes.NewHeight(-100)}, baseIDs.GenerateHashID()},
 		{"Test for +ve value", fields{baseTypes.NewHeight(100)}, baseIDs.GenerateHashID(heightData{baseTypes.NewHeight(100)}.Bytes())},
@@ -144,7 +144,7 @@ func Test_heightData_Get(t *testing.T) {
 		fields fields
 		want   types.Height
 	}{
-
+		{"+ve with nil", fields{}, baseTypes.NewHeight(-1)},
 		{"Test for zero value", fields{baseTypes.NewHeight(0)}, heightData{baseTypes.NewHeight(0)}.Value},
 		{"Test for +ve value", fields{baseTypes.NewHeight(100)}, heightData{baseTypes.NewHeight(100)}.Value},
 		{"Test for -ve value", fields{baseTypes.NewHeight(-100)}, heightData{baseTypes.NewHeight(-100)}.Value},
@@ -273,7 +273,7 @@ func Test_heightData_Bytes(t *testing.T) {
 		want   []byte
 	}{
 		{"+ve with ZeroHeight", fields{baseTypes.NewHeight(-1)}, baseTypes.NewHeight(-1).Bytes()},
-		{"+ve with nil", fields{nil}, []byte{}},
+		{"+ve with nil", fields{nil}, baseTypes.NewHeight(-1).Bytes()},
 		{"+ve", fields{baseTypes.NewHeight(100)}, baseTypes.NewHeight(100).Bytes()},
 		{"+ve with max int", fields{baseTypes.NewHeight(int64(^uint(0) >> 1))}, baseTypes.NewHeight(int64(^uint(0) >> 1)).Bytes()},
 	}

schema/data/base/idData.go

@@ -29,12 +29,26 @@ func (idData idData) Compare(listable traits.Listable) int {
 		panic(err)
 	}
 
+	if sanitizedIDData, err := idData.Sanitize(); err != nil {
+		idData.Value = sanitizedIDData.(data.IDData).Get()
+	}
+
+	if sanitizedCompareIDData, err := compareIDData.Sanitize(); err != nil {
+		compareIDData.Value = sanitizedCompareIDData.(data.IDData).Get()
+	}
+
 	return bytes.Compare(idData.Value.Bytes(), compareIDData.Value.Bytes())
 }
 func (idData idData) String() string {
+	if sanitizedIDData, err := idData.Sanitize(); err != nil {
+		idData.Value = sanitizedIDData.(data.IDData).Get()
+	}
 	return idData.Value.String()
 }
 func (idData idData) Bytes() []byte {
+	if sanitizedIDData, err := idData.Sanitize(); err != nil {
+		idData.Value = sanitizedIDData.(data.IDData).Get()
+	}
 	return idData.Value.Bytes()
 }
 func (idData idData) GetType() ids.StringID {
@@ -47,9 +61,19 @@ func (idData idData) GenerateHashID() ids.HashID {
 	return baseIDs.GenerateHashID(idData.Bytes())
 }
 func (idData idData) Get() ids.ID {
+	if sanitizedIDData, err := idData.Sanitize(); err != nil {
+		return sanitizedIDData.(data.IDData).Get()
+	}
 	return idData.Value
 }
 
+func (idData idData) Sanitize() (data.Data, error) {
+	if idData.Value == nil {
+		return idData.ZeroValue(), constants.MetaDataError
+	}
+	return idData, nil
+}
+
 func idDataFromInterface(listable traits.Listable) (idData, error) {
 	switch value := listable.(type) {
 	case idData:

schema/data/base/idData_test.go

@@ -47,7 +47,6 @@ func Test_idDataFromInterface(t *testing.T) {
 	}{
 		{"+ve", args{NewIDData(NewStringData("Data"))}, idData{NewStringData("Data")}, assert.NoError},
 		{"+ve", args{NewIDData(NewStringData(""))}, idData{NewStringData("")}, assert.NoError},
-		{"-ve", args{NewStringData("Data")}, idData{}, assert.Error},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -69,6 +68,7 @@ func Test_idData_Bytes(t *testing.T) {
 		fields fields
 		want   []byte
 	}{
+		{"+ve with nil", fields{nil}, []byte{}},
 		{"+ve", fields{NewStringData("")}, []byte{}},
 		{"+ve", fields{NewStringData("Data")}, NewStringData("Data").Bytes()},
 	}
@@ -95,6 +95,7 @@ func Test_idData_Compare(t *testing.T) {
 		args   args
 		want   int
 	}{
+		{"+ve with nil", fields{nil}, args{idData{}}, 0},
 		{"+ve", fields{NewStringData("Data")}, args{idData{NewStringData("Data")}}, 0},
 		{"+ve", fields{NewStringData("Data")}, args{idData{NewStringData("0")}}, 1},
 	}
@@ -139,6 +140,7 @@ func Test_idData_Get(t *testing.T) {
 		fields fields
 		want   ids.ID
 	}{
+		{"+ve with nil", fields{nil}, baseIDs.NewStringID("")},
 		{"+ve", fields{NewStringData("Data")}, NewStringData("Data")},
 		{"+ve", fields{NewStringData("")}, NewStringData("")},
 	}
@@ -203,6 +205,7 @@ func Test_idData_String(t *testing.T) {
 		fields fields
 		want   string
 	}{
+		{"+ve with nil", fields{nil}, ""},
 		{"+ve", fields{NewStringData("Data")}, "Data"},
 	}
 	for _, tt := range tests {

schema/data/base/listData.go

@@ -24,17 +24,29 @@ type listData struct {
 var _ data.ListData = (*listData)(nil)
 
 func (listData listData) Get() []data.Data {
+	if sanitizedData, err := listData.Sanitize(); err != nil {
+		listData.Value = base.NewDataList(sanitizedData.(data.ListData).Get()...)
+	}
 	return listData.Value.GetList()
 }
-func (listData listData) Search(data data.Data) (int, bool) {
-	return listData.Value.Search(data)
+func (listData listData) Search(_data data.Data) (int, bool) {
+	if sanitizedData, err := listData.Sanitize(); err != nil {
+		listData.Value = base.NewDataList(sanitizedData.(data.ListData).Get()...)
+	}
+	return listData.Value.Search(_data)
 }
-func (listData listData) Add(data ...data.Data) data.ListData {
-	listData.Value = listData.Value.Add(data...)
+func (listData listData) Add(_data ...data.Data) data.ListData {
+	if sanitizedData, err := listData.Sanitize(); err != nil {
+		listData.Value = base.NewDataList(sanitizedData.(data.ListData).Get()...)
+	}
+	listData.Value = listData.Value.Add(_data...)
 	return listData
 }
-func (listData listData) Remove(data ...data.Data) data.ListData {
-	listData.Value = listData.Value.Remove(data...)
+func (listData listData) Remove(_data ...data.Data) data.ListData {
+	if sanitizedData, err := listData.Sanitize(); err != nil {
+		listData.Value = base.NewDataList(sanitizedData.(data.ListData).Get()...)
+	}
+	listData.Value = listData.Value.Remove(_data...)
 	return listData
 }
 func (listData listData) GetID() ids.DataID {
@@ -59,6 +71,9 @@ func (listData listData) String() string {
 	return stringUtilities.JoinListStrings(dataStrings...)
 }
 func (listData listData) Bytes() []byte {
+	if sanitizedData, err := listData.Sanitize(); err != nil {
+		listData.Value = base.NewDataList(sanitizedData.(data.ListData).Get()...)
+	}
 	bytesList := make([][]byte, listData.Value.Size())
 
 	for i, datum := range listData.Value.GetList() {
@@ -83,6 +98,15 @@ func (listData listData) GenerateHashID() ids.HashID {
 
 	return baseIDs.GenerateHashID(listData.Bytes())
 }
+
+func (listData listData) Sanitize() (data.Data, error) {
+	//TODO implement me
+	if listData.Value == nil {
+		return listData.ZeroValue(), errorConstants.MetaDataError
+	}
+	return listData, nil
+}
+
 func listDataFromInterface(listable traits.Listable) (listData, error) {
 	switch value := listable.(type) {
 	case listData: