Merge pull request #85 from HorizenOfficial/as/bigint_json_representation

As/bigint json representation

Author: paolocappelletti

app/simple/app/app_test.go

@@ -686,11 +686,11 @@ func TestBigIntUint256JSONRoundTrip(t *testing.T) {
 	orig := new(big.Int)
 	orig.SetString("115792089237316195423570985008687907853269984665640564039457584007913129639935", 10) // 2^256-1
 
-	// Step 2: marshal big.Int into JSON
+	// Step 2: marshal *common.Big into JSON
 	type HostStruct struct {
-		Amount *big.Int `json:"amount"`
+		Amount *common.Big `json:"amount"`
 	}
-	hostObj := HostStruct{Amount: orig}
+	hostObj := HostStruct{Amount: common.ToBig(orig)}
 
 	jsonData, err := json.Marshal(hostObj)
 	if err != nil {
@@ -721,9 +721,130 @@ func TestBigIntUint256JSONRoundTrip(t *testing.T) {
 	}
 
 	// Step 6: compare
-	if orig.Cmp(hostObj2.Amount) != 0 {
+	if orig.Cmp(hostObj2.Amount.ToInt()) != 0 {
 		t.Errorf("round-trip mismatch:\noriginal: %s\nfinal:    %s", orig.String(), hostObj2.Amount.String())
 	} else {
 		t.Logf("Round-trip successful: value preserved exactly")
 	}
 }
+
+// TestUint256BigJSONCompatibility verifies that Uint256 and common.Big produce
+// identical JSON representations and can be unmarshaled interchangeably.
+func TestUint256BigJSONCompatibility(t *testing.T) {
+	// Test values covering edge cases
+	testValues := []struct {
+		name    string
+		decimal string
+		hex     string
+	}{
+		{"zero", "0", "0x0"},
+		{"one", "1", "0x1"},
+		{"small", "255", "0xff"},
+		{"medium", "12345", "0x3039"},
+		{"large", "12345678901234567890", "0xab54a98ceb1f0ad2"},
+		{"max_uint64", "18446744073709551615", "0xffffffffffffffff"},
+		{"max_uint128", "340282366920938463463374607431768211455", "0xffffffffffffffffffffffffffffffff"},
+		{"max_uint256", "115792089237316195423570985008687907853269984665640564039457584007913129639935", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+	}
+
+	for _, tt := range testValues {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create big.Int from decimal
+			bi, ok := new(big.Int).SetString(tt.decimal, 10)
+			require.True(t, ok, "Failed to parse decimal: %s", tt.decimal)
+
+			// Create common.Big and Uint256 from the same value
+			bigVal := common.ToBig(bi)
+			uint256Val := new(Uint256).SetBytes(bi.Bytes())
+
+			// Marshal both to JSON
+			bigJSON, err := json.Marshal(bigVal)
+			require.NoError(t, err, "Failed to marshal common.Big")
+
+			uint256JSON, err := json.Marshal(uint256Val)
+			require.NoError(t, err, "Failed to marshal Uint256")
+
+			// Verify JSON is byte-for-byte identical
+			require.Equal(t, string(bigJSON), string(uint256JSON),
+				"JSON mismatch for %s:\n  common.Big: %s\n  Uint256:    %s",
+				tt.name, string(bigJSON), string(uint256JSON))
+
+			// Verify JSON matches expected hex format
+			expectedJSON := `"` + tt.hex + `"`
+			require.Equal(t, expectedJSON, string(bigJSON),
+				"Unexpected JSON format for %s", tt.name)
+
+			// Test cross-type unmarshal: Big JSON → Uint256
+			var u256FromBig Uint256
+			err = json.Unmarshal(bigJSON, &u256FromBig)
+			require.NoError(t, err, "Failed to unmarshal Big JSON into Uint256")
+			require.Equal(t, tt.decimal, u256FromBig.String(),
+				"Value mismatch after Big→Uint256 unmarshal")
+
+			// Test cross-type unmarshal: Uint256 JSON → Big
+			var bigFromU256 common.Big
+			err = json.Unmarshal(uint256JSON, &bigFromU256)
+			require.NoError(t, err, "Failed to unmarshal Uint256 JSON into Big")
+			require.Equal(t, tt.decimal, bigFromU256.String(),
+				"Value mismatch after Uint256→Big unmarshal")
+		})
+	}
+}
+
+// TestUint256BigStructCompatibility verifies that structs containing Uint256
+// and common.Big fields produce compatible JSON.
+func TestUint256BigStructCompatibility(t *testing.T) {
+	// Simulate host-side struct (uses common.Big)
+	type HostStruct struct {
+		Amount  *common.Big `json:"amount"`
+		Fee     *common.Big `json:"fee"`
+		Balance *common.Big `json:"balance"`
+	}
+
+	// Simulate WASM-side struct (uses Uint256)
+	type WASMStruct struct {
+		Amount  Uint256 `json:"amount"`
+		Fee     Uint256 `json:"fee"`
+		Balance Uint256 `json:"balance"`
+	}
+
+	// Create host struct with test values
+	hostStruct := HostStruct{
+		Amount:  common.NewBig(1000000),
+		Fee:     common.NewBig(100),
+		Balance: common.NewBig(999900),
+	}
+
+	// Marshal host struct
+	hostJSON, err := json.Marshal(hostStruct)
+	require.NoError(t, err)
+	t.Logf("Host JSON: %s", string(hostJSON))
+
+	// Unmarshal into WASM struct
+	var wasmStruct WASMStruct
+	err = json.Unmarshal(hostJSON, &wasmStruct)
+	require.NoError(t, err)
+
+	// Verify values match
+	require.Equal(t, "1000000", wasmStruct.Amount.String())
+	require.Equal(t, "100", wasmStruct.Fee.String())
+	require.Equal(t, "999900", wasmStruct.Balance.String())
+
+	// Marshal WASM struct back
+	wasmJSON, err := json.Marshal(wasmStruct)
+	require.NoError(t, err)
+	t.Logf("WASM JSON: %s", string(wasmJSON))
+
+	// JSON should be identical
+	require.JSONEq(t, string(hostJSON), string(wasmJSON))
+
+	// Unmarshal back into host struct
+	var hostStruct2 HostStruct
+	err = json.Unmarshal(wasmJSON, &hostStruct2)
+	require.NoError(t, err)
+
+	// Final values should match original
+	require.Equal(t, 0, hostStruct.Amount.ToInt().Cmp(hostStruct2.Amount.ToInt()))
+	require.Equal(t, 0, hostStruct.Fee.ToInt().Cmp(hostStruct2.Fee.ToInt()))
+	require.Equal(t, 0, hostStruct.Balance.ToInt().Cmp(hostStruct2.Balance.ToInt()))
+}

app/simple/app/uint256.go

@@ -2,11 +2,9 @@ package app
 
 import (
 	"encoding/binary"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"math/bits"
-	"strings"
 )
 
 // Uint256 represents a 256-bit unsigned integer using 4 uint64 values.
@@ -137,52 +135,82 @@ func (z Uint256) divModWord(divisor uint64) (Uint256, uint64) {
 	return quot, r
 }
 
+// ToHex returns the hex representation of z with "0x" prefix.
+func (z Uint256) ToHex() string {
+	if z.IsZero() {
+		return "0x0"
+	}
+	// Similar logic to String() but base 16
+	val := z
+	res := make([]byte, 0, 66) // 0x + 64 hex digits
+
+	const sixteen = uint64(16)
+	const hexChars = "0123456789abcdef"
+
+	for !val.IsZero() {
+		var rem uint64
+		val, rem = val.divModWord(sixteen)
+		res = append(res, hexChars[rem])
+	}
+	res = append(res, 'x', '0')
+
+	// reverse
+	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
+		res[i], res[j] = res[j], res[i]
+	}
+	return string(res)
+}
+
 // MarshalJSON implements json.Marshaler.
-// It marshals the Uint256 as a JSON number (no quotes)
-// math/big.Int marshals as digits.
+// It marshals the Uint256 as a hex string with 0x prefix.
 func (z Uint256) MarshalJSON() ([]byte, error) {
-	return []byte(z.String()), nil
+	s := z.ToHex()
+	buf := make([]byte, 0, len(s)+2)
+	buf = append(buf, '"')
+	buf = append(buf, s...)
+	buf = append(buf, '"')
+	return buf, nil
 }
 
 // UnmarshalJSON implements json.Unmarshaler.
-// Only decimal strings or numbers are accepted. Overflow returns an error.
+// Only hex strings with "0x" prefix are accepted.
 func (z *Uint256) UnmarshalJSON(data []byte) error {
-	var s string
-
-	// 1. Determine if input is a JSON string or raw number by peeking the first non-whitespace char using a recursive for loop
-	trimmedData := data
-	for len(trimmedData) > 0 && (trimmedData[0] == ' ' || trimmedData[0] == '\t' || trimmedData[0] == '\n' || trimmedData[0] == '\r') {
-		trimmedData = trimmedData[1:]
+	if string(data) == "null" {
+		*z = Uint256{}
+		return nil
 	}
+	if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' {
+		return fmt.Errorf("invalid Uint256 format: %s", string(data))
+	}
+	s := string(data[1 : len(data)-1])
 
-	if len(trimmedData) > 0 && trimmedData[0] == '"' {
-		// First non-whitespace character is a quote, this is a JSON string
-		if err := json.Unmarshal(data, &s); err != nil {
-			return err
-		}
-	} else {
-		// First non-whitespace character is not a quote, this is a raw JSON number or we have empty input
-		s = string(trimmedData)
+	if len(s) < 2 || s[0] != '0' || s[1] != 'x' {
+		return fmt.Errorf("invalid Uint256 prefix: %s (only lowercase 0x is accepted)", s)
 	}
 
-	// 2. Clean up surrounding whitespace and validate non-empty
-	s = strings.TrimSpace(s)
+	*z = Uint256{}
+	s = s[2:]
 	if len(s) == 0 {
-		return errors.New("Uint256 value is empty")
+		return fmt.Errorf("invalid Uint256 format: empty hex string after 0x prefix")
 	}
 
-	// 3. Strict digit-only parsing
-	*z = Uint256{}
-	const ten = uint64(10)
+	const sixteen = uint64(16)
 	for _, c := range s {
-		if c < '0' || c > '9' {
-			return fmt.Errorf("invalid character in Uint256: %c", c)
+		var digit uint64
+		switch {
+		case c >= '0' && c <= '9':
+			digit = uint64(c - '0')
+		case c >= 'a' && c <= 'f':
+			digit = uint64(c - 'a' + 10)
+		case c >= 'A' && c <= 'F':
+			digit = uint64(c - 'A' + 10)
+		default:
+			return fmt.Errorf("invalid hex character in Uint256: %c", c)
 		}
-		digit := uint64(c - '0')
 
-		if z.Mul64Overflow(ten) {
+		if z.Mul64Overflow(sixteen) {
 			// we have modified z actually, but caller must check the error
-			return errors.New("Uint256 overflow after multiplication")
+			return errors.New("Uint256 overflow after mul")
 		}
 		if z.Add64Overflow(digit) {
 			// we have modified z actually, but caller must check the error