Merge pull request #8 from iden3/iden-148/field-as-big-int

Support big integers (as strings)

json/parser_test.go

@@ -25,14 +25,14 @@ func TestGetSerializedData(t *testing.T) {
 			indexValues: []uint32{1, 2, 3, 4, 5, 6, 7, 8},
 			expected: processor.ParsedSlots{
 				IndexA: []byte{
-					1, 0, 0, 0,
-					2, 0, 0, 0,
-					3, 0, 0, 0,
-					4, 0, 0, 0,
-					5, 0, 0, 0,
-					6, 0, 0, 0,
-					7, 0, 0, 0,
-					8, 0, 0, 0,
+					1,
+					2,
+					3,
+					4,
+					5,
+					6,
+					7,
+					8,
 				},
 				IndexB: []byte{},
 				ValueA: []byte{},
@@ -82,14 +82,14 @@ func TestGetSerializedData(t *testing.T) {
 				IndexA: []byte{},
 				IndexB: []byte{},
 				ValueA: []byte{
-					1, 0, 0, 0,
-					2, 0, 0, 0,
-					3, 0, 0, 0,
-					4, 0, 0, 0,
-					5, 0, 0, 0,
-					6, 0, 0, 0,
-					7, 0, 0, 0,
-					8, 0, 0, 0,
+					1,
+					2,
+					3,
+					4,
+					5,
+					6,
+					7,
+					8,
 				},
 				ValueB: []byte{},
 			},

processor/json-ld/processor_test.go

@@ -2,11 +2,13 @@ package jsonld
 
 import (
 	commonJSON "encoding/json"
+	"github.com/iden3/go-iden3-crypto/utils"
 	"github.com/iden3/go-schema-processor/json"
 	jsonld "github.com/iden3/go-schema-processor/json-ld"
 	"github.com/iden3/go-schema-processor/loaders"
 	"github.com/iden3/go-schema-processor/processor"
 	"github.com/stretchr/testify/assert"
+	"math/big"
 	"testing"
 )
 
@@ -36,7 +38,7 @@ func TestParserWithSimpleData(t *testing.T) {
 	assert.Nil(t, err)
 
 	parsedData, err := jsonLdProcessor.ParseSlots(dataBytes, schema)
-	expetctedSlotA := []uint8{24, 0, 0, 0, 4, 0, 0, 0, 204, 7, 0, 0, 1, 0, 0, 0}
+	expetctedSlotA := []uint8{24, 4, 204, 7, 1}
 
 	t.Log(parsedData.IndexA)
 	assert.Nil(t, err)
@@ -73,7 +75,7 @@ func TestParserWithPositionedData(t *testing.T) {
 
 	parsedData, err := jsonLdProcessor.ParseSlots(dataBytes, schema)
 
-	exptectedSlotA := []uint8{24, 0, 0, 0, 4, 0, 0, 0, 204, 7, 0, 0, 1, 0, 0, 0}
+	exptectedSlotA := []uint8{24, 4, 204, 7, 1}
 
 	assert.Nil(t, err)
 	assert.NotEmpty(t, parsedData.IndexA)
@@ -195,7 +197,7 @@ func TestParserWithSlotsTypes(t *testing.T) {
 	assert.Nil(t, err)
 	t.Log(parsedData.IndexA)
 	expetctedSlotA := []uint8{101, 63, 98, 49}
-	expetctedSlotB := []uint8{1, 0, 0, 0}
+	expetctedSlotB := []uint8{1}
 
 	t.Log(parsedData.IndexA)
 	assert.Nil(t, err)
@@ -236,3 +238,44 @@ func TestGetFieldIndexWithSlotsTypes(t *testing.T) {
 	assert.Equal(t, 3, slot3)
 
 }
+
+func TestParserForBigIntegers(t *testing.T) {
+
+	url = "https://raw.githubusercontent.com/iden3/claim-schema-vocab/main/schemas/json-ld/auth.json-ld"
+
+	loader := loaders.HTTP{}
+	validator := json.Validator{}
+	parser := jsonld.Parser{ClaimType: "AuthBJJCredential", ParsingStrategy: processor.OneFieldPerSlotStrategy}
+
+	jsonLdProcessor := New(processor.WithValidator(validator), processor.WithParser(parser), processor.WithSchemaLoader(loader))
+	schema, ext, err := jsonLdProcessor.Load(url)
+
+	assert.Nil(t, err)
+	assert.Equal(t, ext, "json-ld")
+	assert.NotEmpty(t, schema)
+
+	data := make(map[string]interface{})
+
+	data["x"] = "12747559771369266961976321746772881814229091957322087014312756428846389160887"
+	data["y"] = "7732074634595480184356588475330446395691728690271550550016720788712795268212"
+
+	dataBytes, err := commonJSON.Marshal(data)
+	assert.Nil(t, err)
+
+	parsedData, err := jsonLdProcessor.ParseSlots(dataBytes, schema)
+	assert.Nil(t, err)
+
+	x, _ := new(big.Int).SetString(data["x"].(string), 10)
+	y, _ := new(big.Int).SetString(data["y"].(string), 10)
+
+	expetctedSlotA := utils.SwapEndianness(x.Bytes())
+	expetctedSlotB := utils.SwapEndianness(y.Bytes())
+
+	assert.Nil(t, err)
+	assert.NotEmpty(t, parsedData.IndexA)
+	assert.Equal(t, expetctedSlotA, parsedData.IndexA)
+	assert.Equal(t, expetctedSlotB, parsedData.IndexB)
+
+	assert.Empty(t, parsedData.ValueA)
+	assert.Empty(t, parsedData.ValueB)
+}

utils/claims.go

@@ -1,15 +1,13 @@
 package utils
 
 import (
-	"encoding/binary"
 	"encoding/json"
 	"fmt"
 	core "github.com/iden3/go-iden3-core"
 	"github.com/iden3/go-schema-processor/processor"
 	"github.com/iden3/go-schema-processor/verifiable"
 	"github.com/pkg/errors"
 	"math/big"
-	"strconv"
 )
 
 var q *big.Int
@@ -27,24 +25,25 @@ func init() {
 // FieldToByteArray convert fields to byte representation based on type
 func FieldToByteArray(field interface{}) ([]byte, error) {
 
+	var bigIntField *big.Int
+	var ok bool
+
 	switch v := field.(type) {
-	case uint32:
-		bs := make([]byte, 4)
-		binary.LittleEndian.PutUint32(bs, v)
-		return bs, nil
+	case string:
+		bigIntField, ok = new(big.Int).SetString(v, 10)
+		if !ok {
+			return nil, errors.New("can't convert string to big int")
+		}
 	case float64:
-		s := fmt.Sprintf("%.0f", v)
-		intValue, err := strconv.Atoi(s)
-		if err != nil {
-			return nil, fmt.Errorf("can not convert field %v to uint32", field)
+		stringField := fmt.Sprintf("%.0f", v)
+		bigIntField, ok = new(big.Int).SetString(stringField, 10)
+		if !ok {
+			return nil, errors.New("can't convert string to big int")
 		}
-
-		bs := make([]byte, 4)
-		binary.LittleEndian.PutUint32(bs, uint32(intValue))
-		return bs, nil
+	default:
+		return nil, errors.New("field type is not supported")
 	}
-
-	return nil, fmt.Errorf("not supported field type %T", field)
+	return swapEndianness(bigIntField.Bytes()), nil
 }
 
 // DataFillsSlot  checks if newData fills into slot capacity ()